backtest-kit 1.4.11 → 1.4.13

package/build/index.mjs

@@ -5,6 +5,7 @@ import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
 import os from 'os';
+import { promises } from 'fs';
 
 const GLOBAL_CONFIG = {
     /**
@@ -160,6 +161,7 @@ const markdownServices$1 = {
     walkerMarkdownService: Symbol('walkerMarkdownService'),
     heatMarkdownService: Symbol('heatMarkdownService'),
     partialMarkdownService: Symbol('partialMarkdownService'),
+    outlineMarkdownService: Symbol('outlineMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -10460,6 +10462,11 @@ const columns = [
         label: "Symbol",
         format: (data) => data.symbol,
     },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+    },
     {
         key: "signalId",
         label: "Signal ID",
@@ -10494,7 +10501,7 @@ const columns = [
 /** Maximum number of events to store in partial reports */
 const MAX_EVENTS = 250;
 /**
- * Storage class for accumulating partial profit/loss events per symbol.
+ * Storage class for accumulating partial profit/loss events per symbol-strategy pair.
  * Maintains a chronological list of profit and loss level events.
  */
 class ReportStorage {
@@ -10505,17 +10512,17 @@ class ReportStorage {
     /**
      * Adds a profit event to the storage.
      *
-     * @param symbol - Trading pair symbol
      * @param data - Signal row data
      * @param currentPrice - Current market price
      * @param level - Profit level reached
      * @param backtest - True if backtest mode
      */
-    addProfitEvent(symbol, data, currentPrice, level, backtest, timestamp) {
+    addProfitEvent(data, currentPrice, level, backtest, timestamp) {
         this._eventList.push({
             timestamp,
             action: "profit",
-            symbol,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
             signalId: data.id,
             position: data.position,
             currentPrice,
@@ -10530,17 +10537,17 @@ class ReportStorage {
     /**
      * Adds a loss event to the storage.
      *
-     * @param symbol - Trading pair symbol
      * @param data - Signal row data
      * @param currentPrice - Current market price
      * @param level - Loss level reached
      * @param backtest - True if backtest mode
      */
-    addLossEvent(symbol, data, currentPrice, level, backtest, timestamp) {
+    addLossEvent(data, currentPrice, level, backtest, timestamp) {
         this._eventList.push({
             timestamp,
             action: "loss",
-            symbol,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
             signalId: data.id,
             position: data.position,
             currentPrice,
@@ -10576,35 +10583,37 @@ class ReportStorage {
         };
     }
     /**
-     * Generates markdown report with all partial events for a symbol (View).
+     * Generates markdown report with all partial events for a symbol-strategy pair (View).
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol) {
+    async getReport(symbol, strategyName) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
-            return str.newline(`# Partial Profit/Loss Report: ${symbol}`, "", "No partial profit/loss events recorded yet.");
+            return str.newline(`# Partial Profit/Loss Report: ${symbol}:${strategyName}`, "", "No partial profit/loss events recorded yet.");
         }
         const header = columns.map((col) => col.label);
         const separator = columns.map(() => "---");
         const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
-        return str.newline(`# Partial Profit/Loss Report: ${symbol}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Profit events:** ${stats.totalProfit}`, `**Loss events:** ${stats.totalLoss}`);
+        return str.newline(`# Partial Profit/Loss Report: ${symbol}:${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Profit events:** ${stats.totalProfit}`, `**Loss events:** ${stats.totalLoss}`);
     }
     /**
-     * Saves symbol report to disk.
+     * Saves symbol-strategy report to disk.
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/partial")
      */
-    async dump(symbol, path = "./dump/partial") {
-        const markdown = await this.getReport(symbol);
+    async dump(symbol, strategyName, path = "./dump/partial") {
+        const markdown = await this.getReport(symbol, strategyName);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
-            const filename = `${symbol}.md`;
+            const filename = `${symbol}_${strategyName}.md`;
             const filepath = join(dir, filename);
             await writeFile(filepath, markdown, "utf-8");
             console.log(`Partial profit/loss report saved: ${filepath}`);
@@ -10619,10 +10628,10 @@ class ReportStorage {
  *
  * Features:
  * - Listens to partial profit and loss events via partialProfitSubject/partialLossSubject
- * - Accumulates all events (profit, loss) per symbol
+ * - Accumulates all events (profit, loss) per symbol-strategy pair
  * - Generates markdown tables with detailed event information
  * - Provides statistics (total profit/loss events)
- * - Saves reports to disk in dump/partial/{symbol}.md
+ * - Saves reports to disk in dump/partial/{symbol}_{strategyName}.md
  *
  * @example
  * ```typescript
@@ -10632,7 +10641,7 @@ class ReportStorage {
  * // No manual callback setup needed
  *
  * // Later: generate and save report
- * await service.dump("BTCUSDT");
+ * await service.dump("BTCUSDT", "my-strategy");
  * ```
  */
 class PartialMarkdownService {
@@ -10640,10 +10649,10 @@ class PartialMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol.
-         * Each symbol gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol]) => `${symbol}`, () => new ReportStorage());
+        this.getStorage = memoize(([symbol, strategyName]) => JSON.stringify([symbol, strategyName]), () => new ReportStorage());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -10660,8 +10669,8 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickProfit", {
                 data,
             });
-            const storage = this.getStorage(data.symbol);
-            storage.addProfitEvent(data.symbol, data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
+            const storage = this.getStorage(data.symbol, data.data.strategyName);
+            storage.addProfitEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
          * Processes loss events and accumulates them.
@@ -10679,101 +10688,113 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickLoss", {
                 data,
             });
-            const storage = this.getStorage(data.symbol);
-            storage.addLossEvent(data.symbol, data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
+            const storage = this.getStorage(data.symbol, data.data.strategyName);
+            storage.addLossEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
-         * Gets statistical data from all partial profit/loss events for a symbol.
+         * Gets statistical data from all partial profit/loss events for a symbol-strategy pair.
          * Delegates to ReportStorage.getData().
          *
          * @param symbol - Trading pair symbol to get data for
+         * @param strategyName - Strategy name to get data for
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const stats = await service.getData("BTCUSDT");
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
          * console.log(stats.totalProfit, stats.totalLoss);
          * ```
          */
-        this.getData = async (symbol) => {
+        this.getData = async (symbol, strategyName) => {
             this.loggerService.log("partialMarkdownService getData", {
                 symbol,
+                strategyName,
             });
-            const storage = this.getStorage(symbol);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getData();
         };
         /**
-         * Generates markdown report with all partial events for a symbol.
+         * Generates markdown report with all partial events for a symbol-strategy pair.
          * Delegates to ReportStorage.getReport().
          *
          * @param symbol - Trading pair symbol to generate report for
+         * @param strategyName - Strategy name to generate report for
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol) => {
+        this.getReport = async (symbol, strategyName) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
+                strategyName,
             });
-            const storage = this.getStorage(symbol);
-            return storage.getReport(symbol);
+            const storage = this.getStorage(symbol, strategyName);
+            return storage.getReport(symbol, strategyName);
         };
         /**
-         * Saves symbol report to disk.
+         * Saves symbol-strategy report to disk.
          * Creates directory if it doesn't exist.
          * Delegates to ReportStorage.dump().
          *
          * @param symbol - Trading pair symbol to save report for
+         * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/partial")
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
          *
-         * // Save to default path: ./dump/partial/BTCUSDT.md
-         * await service.dump("BTCUSDT");
+         * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy");
          *
-         * // Save to custom path: ./custom/path/BTCUSDT.md
-         * await service.dump("BTCUSDT", "./custom/path");
+         * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, path = "./dump/partial") => {
+        this.dump = async (symbol, strategyName, path = "./dump/partial") => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
+                strategyName,
                 path,
             });
-            const storage = this.getStorage(symbol);
-            await storage.dump(symbol, path);
+            const storage = this.getStorage(symbol, strategyName);
+            await storage.dump(symbol, strategyName, path);
         };
         /**
          * Clears accumulated event data from storage.
-         * If symbol is provided, clears only that symbol's data.
-         * If symbol is omitted, clears all symbols' data.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
          *
-         * @param symbol - Optional symbol to clear specific symbol data
+         * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
          *
-         * // Clear specific symbol data
-         * await service.clear("BTCUSDT");
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
-         * // Clear all symbols' data
+         * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (symbol) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("partialMarkdownService clear", {
-                symbol,
+                ctx,
             });
-            this.getStorage.clear(symbol);
+            if (ctx) {
+                const key = JSON.stringify([ctx.symbol, ctx.strategyName]);
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to partial profit/loss events.
@@ -10904,6 +10925,145 @@ class PartialGlobalService {
     }
 }
 
+/**
+ * Warning threshold for message size in kilobytes.
+ * Messages exceeding this size trigger console warnings.
+ */
+const WARN_KB = 100;
+/**
+ * Internal function for dumping signal data to markdown files.
+ * Creates a directory structure with system prompts, user messages, and LLM output.
+ *
+ * @param signalId - Unique identifier for the result
+ * @param history - Array of message models from LLM conversation
+ * @param signal - Signal DTO with trade parameters
+ * @param outputDir - Output directory path (default: "./dump/strategy")
+ * @returns Promise that resolves when all files are written
+ */
+const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/strategy") => {
+    // Extract system messages and system reminders from existing data
+    const systemMessages = history.filter((m) => m.role === "system");
+    const userMessages = history.filter((m) => m.role === "user");
+    const subfolderPath = path.join(outputDir, String(signalId));
+    try {
+        await promises.access(subfolderPath);
+        return;
+    }
+    catch {
+        await promises.mkdir(subfolderPath, { recursive: true });
+    }
+    {
+        let summary = "# Outline Result Summary\n";
+        {
+            summary += "\n";
+            summary += `**ResultId**: ${String(signalId)}\n`;
+            summary += "\n";
+        }
+        if (signal) {
+            summary += "## Output Data\n\n";
+            summary += "```json\n";
+            summary += JSON.stringify(signal, null, 2);
+            summary += "\n```\n\n";
+        }
+        // Add system messages to summary
+        if (systemMessages.length > 0) {
+            summary += "## System Messages\n\n";
+            systemMessages.forEach((msg, idx) => {
+                summary += `### System Message ${idx + 1}\n\n`;
+                summary += msg.content;
+                summary += "\n";
+            });
+        }
+        const summaryFile = path.join(subfolderPath, "00_system_prompt.md");
+        await promises.writeFile(summaryFile, summary, "utf8");
+    }
+    {
+        await Promise.all(Array.from(userMessages.entries()).map(async ([idx, message]) => {
+            const messageNum = String(idx + 1).padStart(2, "0");
+            const contentFileName = `${messageNum}_user_message.md`;
+            const contentFilePath = path.join(subfolderPath, contentFileName);
+            {
+                const messageSizeBytes = Buffer.byteLength(message.content, "utf8");
+                const messageSizeKb = Math.floor(messageSizeBytes / 1024);
+                if (messageSizeKb > WARN_KB) {
+                    console.warn(`User message ${idx + 1} is ${messageSizeBytes} bytes (${messageSizeKb}kb), which exceeds warning limit`);
+                }
+            }
+            let content = `# User Input ${idx + 1}\n\n`;
+            content += `**ResultId**: ${String(signalId)}\n\n`;
+            content += message.content;
+            content += "\n";
+            await promises.writeFile(contentFilePath, content, "utf8");
+        }));
+    }
+    {
+        const messageNum = String(userMessages.length + 1).padStart(2, "0");
+        const contentFileName = `${messageNum}_llm_output.md`;
+        const contentFilePath = path.join(subfolderPath, contentFileName);
+        let content = "# Full Outline Result\n\n";
+        content += `**ResultId**: ${String(signalId)}\n\n`;
+        if (signal) {
+            content += "## Output Data\n\n";
+            content += "```json\n";
+            content += JSON.stringify(signal, null, 2);
+            content += "\n```\n";
+        }
+        await promises.writeFile(contentFilePath, content, "utf8");
+    }
+};
+/**
+ * Service for generating markdown documentation from LLM outline results.
+ * Used by AI Strategy Optimizer to save debug logs and conversation history.
+ *
+ * Creates directory structure:
+ * - ./dump/strategy/{signalId}/00_system_prompt.md - System messages and output data
+ * - ./dump/strategy/{signalId}/01_user_message.md - First user input
+ * - ./dump/strategy/{signalId}/02_user_message.md - Second user input
+ * - ./dump/strategy/{signalId}/XX_llm_output.md - Final LLM output
+ */
+class OutlineMarkdownService {
+    constructor() {
+        /** Logger service injected via DI */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Dumps signal data and conversation history to markdown files.
+         * Skips if directory already exists to avoid overwriting previous results.
+         *
+         * Generated files:
+         * - 00_system_prompt.md - System messages and output summary
+         * - XX_user_message.md - Each user message in separate file (numbered)
+         * - XX_llm_output.md - Final LLM output with signal data
+         *
+         * @param signalId - Unique identifier for the result (used as directory name)
+         * @param history - Array of message models from LLM conversation
+         * @param signal - Signal DTO with trade parameters (priceOpen, TP, SL, etc.)
+         * @param outputDir - Output directory path (default: "./dump/strategy")
+         * @returns Promise that resolves when all files are written
+         *
+         * @example
+         * ```typescript
+         * await outlineService.dumpSignal(
+         *   "strategy-1",
+         *   conversationHistory,
+         *   { position: "long", priceTakeProfit: 51000, priceStopLoss: 49000, minuteEstimatedTime: 60 }
+         * );
+         * // Creates: ./dump/strategy/strategy-1/00_system_prompt.md
+         * //          ./dump/strategy/strategy-1/01_user_message.md
+         * //          ./dump/strategy/strategy-1/02_llm_output.md
+         * ```
+         */
+        this.dumpSignal = async (signalId, history, signal, outputDir = "./dump/strategy") => {
+            this.loggerService.log("outlineMarkdownService dumpSignal", {
+                signalId,
+                history,
+                signal,
+                outputDir,
+            });
+            return await DUMP_SIGNAL_FN(signalId, history, signal, outputDir);
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -10961,6 +11121,7 @@ class PartialGlobalService {
     provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
     provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
+    provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -11032,6 +11193,7 @@ const markdownServices = {
     walkerMarkdownService: inject(TYPES.walkerMarkdownService),
     heatMarkdownService: inject(TYPES.heatMarkdownService),
     partialMarkdownService: inject(TYPES.partialMarkdownService),
+    outlineMarkdownService: inject(TYPES.outlineMarkdownService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -12698,6 +12860,83 @@ async function getMode() {
     return bt ? "backtest" : "live";
 }
 
+const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
+/**
+ * Dumps signal data and LLM conversation history to markdown files.
+ * Used by AI-powered strategies to save debug logs for analysis.
+ *
+ * Creates a directory structure with:
+ * - 00_system_prompt.md - System messages and output summary
+ * - XX_user_message.md - Each user message in separate file (numbered)
+ * - XX_llm_output.md - Final LLM output with signal data
+ *
+ * Skips if directory already exists to avoid overwriting previous results.
+ *
+ * @param signalId - Unique identifier for the result (used as directory name, e.g., UUID)
+ * @param history - Array of message models from LLM conversation
+ * @param signal - Signal DTO returned by LLM (position, priceOpen, TP, SL, etc.)
+ * @param outputDir - Output directory path (default: "./dump/strategy")
+ * @returns Promise that resolves when all files are written
+ *
+ * @example
+ * ```typescript
+ * import { dumpSignal, getCandles } from "backtest-kit";
+ * import { v4 as uuid } from "uuid";
+ *
+ * addStrategy({
+ *   strategyName: "llm-strategy",
+ *   interval: "5m",
+ *   getSignal: async (symbol) => {
+ *     const messages = [];
+ *
+ *     // Build multi-timeframe analysis conversation
+ *     const candles1h = await getCandles(symbol, "1h", 24);
+ *     messages.push(
+ *       { role: "user", content: `Analyze 1h trend:\n${formatCandles(candles1h)}` },
+ *       { role: "assistant", content: "Trend analyzed" }
+ *     );
+ *
+ *     const candles5m = await getCandles(symbol, "5m", 24);
+ *     messages.push(
+ *       { role: "user", content: `Analyze 5m structure:\n${formatCandles(candles5m)}` },
+ *       { role: "assistant", content: "Structure analyzed" }
+ *     );
+ *
+ *     // Request signal
+ *     messages.push({
+ *       role: "user",
+ *       content: "Generate trading signal. Use position: 'wait' if uncertain."
+ *     });
+ *
+ *     const resultId = uuid();
+ *     const signal = await llmRequest(messages);
+ *
+ *     // Save conversation and result for debugging
+ *     await dumpSignal(resultId, messages, signal);
+ *
+ *     return signal;
+ *   }
+ * });
+ *
+ * // Creates: ./dump/strategy/{uuid}/00_system_prompt.md
+ * //          ./dump/strategy/{uuid}/01_user_message.md (1h analysis)
+ * //          ./dump/strategy/{uuid}/02_assistant_message.md
+ * //          ./dump/strategy/{uuid}/03_user_message.md (5m analysis)
+ * //          ./dump/strategy/{uuid}/04_assistant_message.md
+ * //          ./dump/strategy/{uuid}/05_user_message.md (signal request)
+ * //          ./dump/strategy/{uuid}/06_llm_output.md (final signal)
+ * ```
+ */
+async function dumpSignal(signalId, history, signal, outputDir = "./dump/strategy") {
+    backtest$1.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
+        signalId,
+        history,
+        signal,
+        outputDir,
+    });
+    return await backtest$1.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
+}
+
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
 const BACKTEST_METHOD_NAME_GET_REPORT = "BacktestUtils.getReport";
@@ -13918,26 +14157,26 @@ const PARTIAL_METHOD_NAME_DUMP = "PartialUtils.dump";
  *
  * Data source:
  * - PartialMarkdownService listens to partialProfitSubject/partialLossSubject
- * - Accumulates events in ReportStorage (max 250 events per symbol)
- * - Events include: timestamp, action, symbol, signalId, position, level, price, mode
+ * - Accumulates events in ReportStorage (max 250 events per symbol-strategy pair)
+ * - Events include: timestamp, action, symbol, strategyName, signalId, position, level, price, mode
  *
  * @example
  * ```typescript
  * import { Partial } from "./classes/Partial";
  *
- * // Get statistical data for BTCUSDT
- * const stats = await Partial.getData("BTCUSDT");
+ * // Get statistical data for BTCUSDT:my-strategy
+ * const stats = await Partial.getData("BTCUSDT", "my-strategy");
  * console.log(`Total events: ${stats.totalEvents}`);
  * console.log(`Profit events: ${stats.totalProfit}`);
  * console.log(`Loss events: ${stats.totalLoss}`);
  *
  * // Generate markdown report
- * const markdown = await Partial.getReport("BTCUSDT");
+ * const markdown = await Partial.getReport("BTCUSDT", "my-strategy");
  * console.log(markdown); // Formatted table with all events
  *
  * // Export report to file
- * await Partial.dump("BTCUSDT"); // Saves to ./dump/partial/BTCUSDT.md
- * await Partial.dump("BTCUSDT", "./custom/path"); // Custom directory
+ * await Partial.dump("BTCUSDT", "my-strategy"); // Saves to ./dump/partial/BTCUSDT_my-strategy.md
+ * await Partial.dump("BTCUSDT", "my-strategy", "./custom/path"); // Custom directory
  * ```
  */
 class PartialUtils {
@@ -13949,11 +14188,12 @@ class PartialUtils {
          * Returns aggregated metrics calculated from all profit and loss events.
          *
          * @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
          *
          * @example
          * ```typescript
-         * const stats = await Partial.getData("BTCUSDT");
+         * const stats = await Partial.getData("BTCUSDT", "my-strategy");
          *
          * console.log(`Total events: ${stats.totalEvents}`);
          * console.log(`Profit events: ${stats.totalProfit} (${(stats.totalProfit / stats.totalEvents * 100).toFixed(1)}%)`);
@@ -13965,16 +14205,17 @@ class PartialUtils {
          * }
          * ```
          */
-        this.getData = async (symbol) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol });
-            return await backtest$1.partialMarkdownService.getData(symbol);
+        this.getData = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
+            return await backtest$1.partialMarkdownService.getData(symbol, strategyName);
         };
         /**
-         * Generates markdown report with all partial profit/loss events for a symbol.
+         * Generates markdown report with all partial profit/loss events for a symbol-strategy pair.
          *
          * Creates formatted table containing:
          * - Action (PROFIT/LOSS)
          * - Symbol
+         * - Strategy
          * - Signal ID
          * - Position (LONG/SHORT)
          * - Level % (+10%, -20%, etc)
@@ -13985,35 +14226,36 @@ class PartialUtils {
          * Also includes summary statistics at the end.
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Partial.getReport("BTCUSDT");
+         * const markdown = await Partial.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          *
          * // Output:
-         * // # Partial Profit/Loss Report: BTCUSDT
+         * // # Partial Profit/Loss Report: BTCUSDT:my-strategy
          * //
-         * // | Action | Symbol | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
-         * // | --- | --- | --- | --- | --- | --- | --- | --- |
-         * // | PROFIT | BTCUSDT | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
-         * // | LOSS | BTCUSDT | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
+         * // | Action | Symbol | Strategy | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
+         * // | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+         * // | PROFIT | BTCUSDT | my-strategy | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
+         * // | LOSS | BTCUSDT | my-strategy | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
          * //
          * // **Total events:** 2
          * // **Profit events:** 1
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol });
-            return await backtest$1.partialMarkdownService.getReport(symbol);
+        this.getReport = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
+            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName);
         };
         /**
          * Generates and saves markdown report to file.
          *
          * Creates directory if it doesn't exist.
-         * Filename format: {symbol}.md (e.g., "BTCUSDT.md")
+         * Filename format: {symbol}_{strategyName}.md (e.g., "BTCUSDT_my-strategy.md")
          *
          * Delegates to PartialMarkdownService.dump() which:
          * 1. Generates markdown report via getReport()
@@ -14022,26 +14264,27 @@ class PartialUtils {
          * 4. Logs success/failure to console
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/partial")
          * @returns Promise that resolves when file is written
          *
          * @example
          * ```typescript
-         * // Save to default path: ./dump/partial/BTCUSDT.md
-         * await Partial.dump("BTCUSDT");
+         * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
+         * await Partial.dump("BTCUSDT", "my-strategy");
          *
-         * // Save to custom path: ./reports/partial/BTCUSDT.md
-         * await Partial.dump("BTCUSDT", "./reports/partial");
+         * // Save to custom path: ./reports/partial/BTCUSDT_my-strategy.md
+         * await Partial.dump("BTCUSDT", "my-strategy", "./reports/partial");
          *
          * // After multiple symbols backtested, export all reports
          * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
-         *   await Partial.dump(symbol, "./backtest-results");
+         *   await Partial.dump(symbol, "my-strategy", "./backtest-results");
          * }
          * ```
          */
-        this.dump = async (symbol, path) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, path });
-            await backtest$1.partialMarkdownService.dump(symbol, path);
+        this.dump = async (symbol, strategyName, path) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
+            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path);
         };
     }
 }
@@ -14054,9 +14297,9 @@ class PartialUtils {
  * import { Partial } from "backtest-kit";
  *
  * // Usage same as PartialUtils methods
- * const stats = await Partial.getData("BTCUSDT");
- * const report = await Partial.getReport("BTCUSDT");
- * await Partial.dump("BTCUSDT");
+ * const stats = await Partial.getData("BTCUSDT", "my-strategy");
+ * const report = await Partial.getReport("BTCUSDT", "my-strategy");
+ * await Partial.dump("BTCUSDT", "my-strategy");
  * ```
  */
 const Partial = new PartialUtils();
@@ -14142,4 +14385,4 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
-export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, 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, 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, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, 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, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };