backtest-kit 2.1.2 → 2.2.1

package/build/index.mjs

@@ -1,13 +1,12 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, trycatch, retry, errorData, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, singlerun } from 'functools-kit';
+import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, trycatch, retry, errorData, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
-import fs__default, { mkdir, writeFile } from 'fs/promises';
+import fs__default from 'fs/promises';
 import path, { join, dirname } from 'path';
 import crypto from 'crypto';
 import os from 'os';
 import { createWriteStream } from 'fs';
-import { createRequire } from 'module';
 import { parseArgs as parseArgs$1 } from 'util';
 
 const { init, inject, provide } = createActivator("backtest");
@@ -52,7 +51,6 @@ const connectionServices$1 = {
     sizingConnectionService: Symbol('sizingConnectionService'),
     riskConnectionService: Symbol('riskConnectionService'),
     actionConnectionService: Symbol('actionConnectionService'),
-    optimizerConnectionService: Symbol('optimizerConnectionService'),
     partialConnectionService: Symbol('partialConnectionService'),
     breakevenConnectionService: Symbol('breakevenConnectionService'),
 };
@@ -64,7 +62,6 @@ const schemaServices$1 = {
     sizingSchemaService: Symbol('sizingSchemaService'),
     riskSchemaService: Symbol('riskSchemaService'),
     actionSchemaService: Symbol('actionSchemaService'),
-    optimizerSchemaService: Symbol('optimizerSchemaService'),
 };
 const coreServices$1 = {
     exchangeCoreService: Symbol('exchangeCoreService'),
@@ -75,7 +72,6 @@ const coreServices$1 = {
 const globalServices$1 = {
     sizingGlobalService: Symbol('sizingGlobalService'),
     riskGlobalService: Symbol('riskGlobalService'),
-    optimizerGlobalService: Symbol('optimizerGlobalService'),
     partialGlobalService: Symbol('partialGlobalService'),
     breakevenGlobalService: Symbol('breakevenGlobalService'),
 };
@@ -125,16 +121,9 @@ const validationServices$1 = {
     sizingValidationService: Symbol('sizingValidationService'),
     riskValidationService: Symbol('riskValidationService'),
     actionValidationService: Symbol('actionValidationService'),
-    optimizerValidationService: Symbol('optimizerValidationService'),
     configValidationService: Symbol('configValidationService'),
     columnValidationService: Symbol('columnValidationService'),
 };
-const templateServices$1 = {
-    optimizerTemplateService: Symbol('optimizerTemplateService'),
-};
-const promptServices$1 = {
-    signalPromptService: Symbol('signalPromptService'),
-};
 const TYPES = {
     ...baseServices$1,
     ...contextServices$1,
@@ -148,8 +137,6 @@ const TYPES = {
     ...markdownServices$1,
     ...reportServices$1,
     ...validationServices$1,
-    ...templateServices$1,
-    ...promptServices$1,
 };
 
 /**
@@ -473,11 +460,6 @@ const progressBacktestEmitter = new Subject();
  * Emits progress updates during walker execution.
  */
 const progressWalkerEmitter = new Subject();
-/**
- * Progress emitter for optimizer execution progress.
- * Emits progress updates during optimizer execution.
- */
-const progressOptimizerEmitter = new Subject();
 /**
  * Performance emitter for execution metrics.
  * Emits performance metrics for profiling and bottleneck detection.
@@ -552,7 +534,6 @@ var emitters = /*#__PURE__*/Object.freeze({
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
     progressBacktestEmitter: progressBacktestEmitter,
-    progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
     riskSubject: riskSubject,
     schedulePingSubject: schedulePingSubject,
@@ -1646,6 +1627,7 @@ class PersistCandleUtils {
  */
 const PersistCandleAdapter = new PersistCandleUtils();
 
+const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
@@ -1791,7 +1773,7 @@ const WRITE_CANDLES_CACHE_FN$1 = trycatch(queued(async (candles, dto, self) => {
 const GET_CANDLES_FN = async (dto, since, self) => {
     const step = INTERVAL_MINUTES$4[dto.interval];
     const sinceTimestamp = since.getTime();
-    const untilTimestamp = sinceTimestamp + dto.limit * step * 60 * 1000;
+    const untilTimestamp = sinceTimestamp + dto.limit * step * MS_PER_MINUTE$1;
     // Try to read from cache first
     const cachedCandles = await READ_CANDLES_CACHE_FN$1(dto, sinceTimestamp, untilTimestamp, self);
     if (cachedCandles !== null) {
@@ -1897,7 +1879,7 @@ class ClientExchange {
         if (!adjust) {
             throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
         }
-        const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
+        const since = new Date(this.params.execution.context.when.getTime() - adjust * MS_PER_MINUTE$1);
         let allData = [];
         // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
         if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
@@ -1910,7 +1892,7 @@ class ClientExchange {
                 remaining -= chunkLimit;
                 if (remaining > 0) {
                     // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
                 }
             }
         }
@@ -1957,7 +1939,7 @@ class ClientExchange {
         const now = Date.now();
         // Вычисляем конечное время запроса
         const step = INTERVAL_MINUTES$4[interval];
-        const endTime = since.getTime() + limit * step * 60 * 1000;
+        const endTime = since.getTime() + limit * step * MS_PER_MINUTE$1;
         // Проверяем что запрошенный период не заходит за Date.now()
         if (endTime > now) {
             return [];
@@ -1974,7 +1956,7 @@ class ClientExchange {
                 remaining -= chunkLimit;
                 if (remaining > 0) {
                     // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
                 }
             }
         }
@@ -2069,22 +2051,19 @@ class ClientExchange {
     /**
      * Fetches raw candles with flexible date/limit parameters.
      *
-     * Compatibility layer that:
-     * - RAW MODE (sDate + eDate + limit): fetches exactly as specified, NO look-ahead bias protection
-     * - Other modes: respects execution context and prevents look-ahead bias
+     * All modes respect execution context and prevent look-ahead bias.
      *
      * Parameter combinations:
-     * 1. sDate + eDate + limit: RAW MODE - fetches exactly as specified, no validation against when
-     * 2. sDate + eDate: calculates limit from date range, validates endTimestamp <= when
-     * 3. eDate + limit: calculates sDate backward, validates endTimestamp <= when
-     * 4. sDate + limit: fetches forward, validates endTimestamp <= when
+     * 1. sDate + eDate + limit: fetches with explicit parameters, validates eDate <= when
+     * 2. sDate + eDate: calculates limit from date range, validates eDate <= when
+     * 3. eDate + limit: calculates sDate backward, validates eDate <= when
+     * 4. sDate + limit: fetches forward, validates calculated endTimestamp <= when
      * 5. Only limit: uses execution.context.when as reference (backward)
      *
      * Edge cases:
      * - If calculated limit is 0 or negative: throws error
      * - If sDate >= eDate: throws error
-     * - If startTimestamp >= endTimestamp: throws error
-     * - If endTimestamp > when (non-RAW modes only): throws error to prevent look-ahead bias
+     * - If eDate > when: throws error to prevent look-ahead bias
      *
      * @param symbol - Trading pair symbol
      * @param interval - Candle interval
@@ -2103,73 +2082,75 @@ class ClientExchange {
             eDate,
         });
         const step = INTERVAL_MINUTES$4[interval];
-        const stepMs = step * 60 * 1000;
-        const when = this.params.execution.context.when.getTime();
-        let startTimestamp;
-        let endTimestamp;
-        let candleLimit;
-        let isRawMode = false;
-        // Case 1: sDate + eDate + limit - RAW MODE (no look-ahead bias protection)
-        if (sDate !== undefined &&
-            eDate !== undefined &&
-            limit !== undefined) {
-            isRawMode = true;
+        if (!step) {
+            throw new Error(`ClientExchange getRawCandles: unknown interval=${interval}`);
+        }
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        let sinceTimestamp;
+        let untilTimestamp;
+        let calculatedLimit;
+        // Case 1: all three parameters provided
+        if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
             if (sDate >= eDate) {
-                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be less than eDate (${eDate})`);
+                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
             }
-            startTimestamp = sDate;
-            endTimestamp = eDate;
-            candleLimit = limit;
+            if (eDate > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            sinceTimestamp = sDate;
+            untilTimestamp = eDate;
+            calculatedLimit = limit;
         }
-        // Case 2: sDate + eDate - calculate limit, respect backtest context
+        // Case 2: sDate + eDate (no limit) - calculate limit from date range
         else if (sDate !== undefined && eDate !== undefined && limit === undefined) {
             if (sDate >= eDate) {
-                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be less than eDate (${eDate})`);
-            }
-            startTimestamp = sDate;
-            endTimestamp = eDate;
-            const rangeDuration = endTimestamp - startTimestamp;
-            candleLimit = Math.floor(rangeDuration / stepMs);
-            if (candleLimit <= 0) {
-                throw new Error(`ClientExchange getRawCandles: calculated limit is ${candleLimit} for range [${sDate}, ${eDate}]`);
-            }
-        }
-        // Case 3: eDate + limit - calculate sDate backward, respect backtest context
-        else if (eDate !== undefined && limit !== undefined && sDate === undefined) {
-            endTimestamp = eDate;
-            startTimestamp = eDate - limit * stepMs;
-            candleLimit = limit;
-        }
-        // Case 4: sDate + limit - fetch forward, respect backtest context
-        else if (sDate !== undefined && limit !== undefined && eDate === undefined) {
-            startTimestamp = sDate;
-            endTimestamp = sDate + limit * stepMs;
-            candleLimit = limit;
-        }
-        // Case 5: Only limit - use execution context (backward from when)
-        else if (limit !== undefined && sDate === undefined && eDate === undefined) {
-            endTimestamp = when;
-            startTimestamp = when - limit * stepMs;
-            candleLimit = limit;
-        }
-        // Invalid combination
-        else {
-            throw new Error(`ClientExchange getRawCandles: invalid parameter combination. Must provide either (limit), (eDate+limit), (sDate+limit), (sDate+eDate), or (sDate+eDate+limit)`);
+                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+            }
+            if (eDate > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            sinceTimestamp = sDate;
+            untilTimestamp = eDate;
+            calculatedLimit = Math.ceil((eDate - sDate) / (step * MS_PER_MINUTE$1));
+            if (calculatedLimit <= 0) {
+                throw new Error(`ClientExchange getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
+            }
+        }
+        // Case 3: eDate + limit (no sDate) - calculate sDate backward from eDate
+        else if (sDate === undefined && eDate !== undefined && limit !== undefined) {
+            if (eDate > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            untilTimestamp = eDate;
+            sinceTimestamp = eDate - limit * step * MS_PER_MINUTE$1;
+            calculatedLimit = limit;
+        }
+        // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
+        else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
+            sinceTimestamp = sDate;
+            untilTimestamp = sDate + limit * step * MS_PER_MINUTE$1;
+            if (untilTimestamp > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${untilTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            calculatedLimit = limit;
         }
-        // Validate timestamps
-        if (startTimestamp >= endTimestamp) {
-            throw new Error(`ClientExchange getRawCandles: startTimestamp (${startTimestamp}) >= endTimestamp (${endTimestamp})`);
+        // Case 5: Only limit - use execution.context.when as reference (backward like getCandles)
+        else if (sDate === undefined && eDate === undefined && limit !== undefined) {
+            untilTimestamp = whenTimestamp;
+            sinceTimestamp = whenTimestamp - limit * step * MS_PER_MINUTE$1;
+            calculatedLimit = limit;
         }
-        // Check if trying to fetch future data (prevent look-ahead bias)
-        // ONLY for non-RAW modes - RAW MODE bypasses this check
-        if (!isRawMode && endTimestamp > when) {
-            throw new Error(`ClientExchange getRawCandles: endTimestamp (${endTimestamp}) is beyond execution context when (${when}) - look-ahead bias prevented`);
+        // Invalid: no parameters or only sDate or only eDate
+        else {
+            throw new Error(`ClientExchange getRawCandles: invalid parameter combination. ` +
+                `Provide one of: (sDate+eDate+limit), (sDate+eDate), (eDate+limit), (sDate+limit), or (limit only). ` +
+                `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
         }
-        const since = new Date(startTimestamp);
+        // Fetch candles using existing logic
+        const since = new Date(sinceTimestamp);
         let allData = [];
-        // Fetch data in chunks if limit exceeds max per request
-        if (candleLimit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
-            let remaining = candleLimit;
+        if (calculatedLimit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = calculatedLimit;
             let currentSince = new Date(since.getTime());
             while (remaining > 0) {
                 const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
@@ -2177,16 +2158,16 @@ class ClientExchange {
                 allData.push(...chunkData);
                 remaining -= chunkLimit;
                 if (remaining > 0) {
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
                 }
             }
         }
         else {
-            allData = await GET_CANDLES_FN({ symbol, interval, limit: candleLimit }, since, this);
+            allData = await GET_CANDLES_FN({ symbol, interval, limit: calculatedLimit }, since, this);
         }
         // Filter candles to strictly match the requested range
-        const filteredData = allData.filter((candle) => candle.timestamp >= startTimestamp &&
-            candle.timestamp < endTimestamp);
+        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp &&
+            candle.timestamp < untilTimestamp);
         // Apply distinct by timestamp to remove duplicates
         const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
         if (filteredData.length !== uniqueData.length) {
@@ -2194,12 +2175,12 @@ class ClientExchange {
             this.params.logger.warn(msg);
             console.warn(msg);
         }
-        if (uniqueData.length < candleLimit) {
-            const msg = `ClientExchange getRawCandles: Expected ${candleLimit} candles, got ${uniqueData.length}`;
+        if (uniqueData.length < calculatedLimit) {
+            const msg = `ClientExchange getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`;
             this.params.logger.warn(msg);
             console.warn(msg);
         }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, candleLimit, uniqueData);
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, calculatedLimit, uniqueData);
         return uniqueData;
     }
     /**
@@ -2221,7 +2202,7 @@ class ClientExchange {
         });
         const to = new Date(this.params.execution.context.when.getTime());
         const from = new Date(to.getTime() -
-            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
+            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$1);
         return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
     }
 }
@@ -2412,6 +2393,28 @@ class ExchangeConnectionService {
             });
             return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candle data
+         */
+        this.getRawCandles = async (symbol, interval, limit, sDate, eDate) => {
+            this.loggerService.log("exchangeConnectionService getRawCandles", {
+                symbol,
+                interval,
+                limit,
+                sDate,
+                eDate,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getRawCandles(symbol, interval, limit, sDate, eDate);
+        };
     }
 }
 
@@ -9955,6 +9958,40 @@ class ExchangeCoreService {
                 backtest,
             });
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters and execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param when - Timestamp for context (used in backtest mode)
+         * @param backtest - Whether running in backtest mode
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candles
+         */
+        this.getRawCandles = async (symbol, interval, when, backtest, limit, sDate, eDate) => {
+            this.loggerService.log("exchangeCoreService getRawCandles", {
+                symbol,
+                interval,
+                when,
+                backtest,
+                limit,
+                sDate,
+                eDate,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getRawCandles requires a method context");
+            }
+            await this.validate(this.methodContextService.context.exchangeName);
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getRawCandles(symbol, interval, limit, sDate, eDate);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
     }
 }
 
@@ -18344,1469 +18381,120 @@ class ActionValidationService {
 }
 
 /**
- * Default template service for generating optimizer code snippets.
- * Implements all IOptimizerTemplate methods with Ollama LLM integration.
+ * Symbol marker indicating that partial state needs initialization.
+ * Used as sentinel value for _states before waitForInit() is called.
+ */
+const NEED_FETCH$1 = Symbol("need_fetch");
+/**
+ * Array of profit level milestones to track (10%, 20%, ..., 100%).
+ * Each level is checked during profit() method to emit events for newly reached levels.
+ */
+const PROFIT_LEVELS = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+/**
+ * Array of loss level milestones to track (-10%, -20%, ..., -100%).
+ * Each level is checked during loss() method to emit events for newly reached levels.
+ */
+const LOSS_LEVELS = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+/**
+ * Internal profit handler function for ClientPartial.
  *
- * Features:
- * - Multi-timeframe analysis (1m, 5m, 15m, 1h)
- * - JSON structured output for signals
- * - Debug logging to ./dump/strategy
- * - CCXT exchange integration
- * - Walker-based strategy comparison
+ * Checks which profit levels have been reached and emits events for new levels only.
+ * Uses Set-based deduplication to prevent duplicate events.
  *
- * Can be partially overridden in optimizer schema configuration.
+ * @param symbol - Trading pair symbol
+ * @param data - Signal row data
+ * @param currentPrice - Current market price
+ * @param revenuePercent - Current profit percentage (positive value)
+ * @param backtest - True if backtest mode
+ * @param when - Event timestamp
+ * @param self - ClientPartial instance reference
  */
-class OptimizerTemplateService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        /**
-         * Generates the top banner with imports and constants.
-         *
-         * @param symbol - Trading pair symbol
-         * @returns Shebang, imports, and WARN_KB constant
-         */
-        this.getTopBanner = async (symbol) => {
-            this.loggerService.log("optimizerTemplateService getTopBanner", {
-                symbol,
-            });
-            return [
-                "#!/usr/bin/env node",
-                "",
-                `import { Ollama } from "ollama";`,
-                `import ccxt from "ccxt";`,
-                `import {`,
-                `    addExchangeSchema,`,
-                `    addStrategySchema,`,
-                `    addFrameSchema,`,
-                `    addWalkerSchema,`,
-                `    Walker,`,
-                `    Backtest,`,
-                `    getCandles,`,
-                `    listenSignalBacktest,`,
-                `    listenWalkerComplete,`,
-                `    listenDoneBacktest,`,
-                `    listenBacktestProgress,`,
-                `    listenWalkerProgress,`,
-                `    listenError,`,
-                `    Markdown,`,
-                `} from "backtest-kit";`,
-                `import { promises as fs } from "fs";`,
-                `import { v4 as uuid } from "uuid";`,
-                `import path from "path";`,
-                ``,
-                `const WARN_KB = 100;`,
-                ``,
-                `Markdown.enable()`,
-            ].join("\n");
-        };
-        /**
-         * Generates default user message for LLM conversation.
-         * Simple prompt to read and acknowledge data.
-         *
-         * @param symbol - Trading pair symbol
-         * @param data - Fetched data array
-         * @param name - Source name
-         * @returns User message with JSON data
-         */
-        this.getUserMessage = async (symbol, data, name) => {
-            this.loggerService.log("optimizerTemplateService getUserMessage", {
-                symbol,
-                data,
-                name,
-            });
-            return ["Прочитай данные и скажи ОК", "", JSON.stringify(data)].join("\n");
-        };
-        /**
-         * Generates default assistant message for LLM conversation.
-         * Simple acknowledgment response.
-         *
-         * @param symbol - Trading pair symbol
-         * @param data - Fetched data array
-         * @param name - Source name
-         * @returns Assistant acknowledgment message
-         */
-        this.getAssistantMessage = async (symbol, data, name) => {
-            this.loggerService.log("optimizerTemplateService getAssistantMessage", {
-                symbol,
-                data,
-                name,
-            });
-            return "ОК";
-        };
-        /**
-         * Generates Walker configuration code.
-         * Compares multiple strategies on test frame.
-         *
-         * @param walkerName - Unique walker identifier
-         * @param exchangeName - Exchange to use for backtesting
-         * @param frameName - Test frame name
-         * @param strategies - Array of strategy names to compare
-         * @returns Generated addWalker() call
-         */
-        this.getWalkerTemplate = async (walkerName, exchangeName, frameName, strategies) => {
-            this.loggerService.log("optimizerTemplateService getWalkerTemplate", {
-                walkerName,
-                exchangeName,
-                frameName,
-                strategies,
-            });
-            // Escape special characters to prevent code injection
-            const escapedWalkerName = String(walkerName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedExchangeName = String(exchangeName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedFrameName = String(frameName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedStrategies = strategies.map((s) => String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"'));
-            return [
-                `addWalkerSchema({`,
-                `    walkerName: "${escapedWalkerName}",`,
-                `    exchangeName: "${escapedExchangeName}",`,
-                `    frameName: "${escapedFrameName}",`,
-                `    strategies: [${escapedStrategies.map((s) => `"${s}"`).join(", ")}],`,
-                `});`
-            ].join("\n");
-        };
-        /**
-         * Generates Strategy configuration with LLM integration.
-         * Includes multi-timeframe analysis and signal generation.
-         *
-         * @param strategyName - Unique strategy identifier
-         * @param interval - Signal throttling interval (e.g., "5m")
-         * @param prompt - Strategy logic from getPrompt()
-         * @returns Generated addStrategy() call with getSignal() function
-         */
-        this.getStrategyTemplate = async (strategyName, interval, prompt) => {
-            this.loggerService.log("optimizerTemplateService getStrategyTemplate", {
-                strategyName,
-                interval,
-                prompt,
-            });
-            // Convert prompt to plain text first
-            const plainPrompt = toPlainString(prompt);
-            // Escape special characters to prevent code injection
-            const escapedStrategyName = String(strategyName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedInterval = String(interval)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedPrompt = String(plainPrompt)
-                .replace(/\\/g, '\\\\')
-                .replace(/`/g, '\\`')
-                .replace(/\$/g, '\\$');
-            return [
-                `addStrategySchema({`,
-                `    strategyName: "${escapedStrategyName}",`,
-                `    interval: "${escapedInterval}",`,
-                `    getSignal: async (symbol) => {`,
-                `        const messages = [];`,
-                ``,
-                `        // Загружаем данные всех таймфреймов`,
-                `        const microTermCandles = await getCandles(symbol, "1m", 30);`,
-                `        const mainTermCandles = await getCandles(symbol, "5m", 24);`,
-                `        const shortTermCandles = await getCandles(symbol, "15m", 24);`,
-                `        const mediumTermCandles = await getCandles(symbol, "1h", 24);`,
-                ``,
-                `        function formatCandles(candles, timeframe) {`,
-                `            return candles.map((c) =>`,
-                `                \`\${new Date(c.timestamp).toISOString()}[\${timeframe}]: O:\${c.open} H:\${c.high} L:\${c.low} C:\${c.close} V:\${c.volume}\``,
-                `            ).join("\\n");`,
-                `        }`,
-                ``,
-                `        // Сообщение 1: Среднесрочный тренд`,
-                `        messages.push(`,
-                `            {`,
-                `                role: "user",`,
-                `                content: [`,
-                `                    \`\${symbol}\`,`,
-                `                    "Проанализируй свечи 1h:",`,
-                `                    "",`,
-                `                    formatCandles(mediumTermCandles, "1h")`,
-                `                ].join("\\n"),`,
-                `            },`,
-                `            {`,
-                `                role: "assistant",`,
-                `                content: "Тренд 1h проанализирован",`,
-                `            }`,
-                `        );`,
-                ``,
-                `        // Сообщение 2: Краткосрочный тренд`,
-                `        messages.push(`,
-                `            {`,
-                `                role: "user",`,
-                `                content: [`,
-                `                    "Проанализируй свечи 15m:",`,
-                `                    "",`,
-                `                    formatCandles(shortTermCandles, "15m")`,
-                `                ].join("\\n"),`,
-                `            },`,
-                `            {`,
-                `                role: "assistant",`,
-                `                content: "Тренд 15m проанализирован",`,
-                `            }`,
-                `        );`,
-                ``,
-                `        // Сообщение 3: Основной таймфрейм`,
-                `        messages.push(`,
-                `            {`,
-                `                role: "user",`,
-                `                content: [`,
-                `                    "Проанализируй свечи 5m:",`,
-                `                    "",`,
-                `                    formatCandles(mainTermCandles, "5m")`,
-                `                ].join("\\n")`,
-                `            },`,
-                `            {`,
-                `                role: "assistant",`,
-                `                content: "Таймфрейм 5m проанализирован",`,
-                `            }`,
-                `        );`,
-                ``,
-                `        // Сообщение 4: Микро-структура`,
-                `        messages.push(`,
-                `            {`,
-                `                role: "user",`,
-                `                content: [`,
-                `                    "Проанализируй свечи 1m:",`,
-                `                    "",`,
-                `                    formatCandles(microTermCandles, "1m")`,
-                `                ].join("\\n")`,
-                `            },`,
-                `            {`,
-                `                role: "assistant",`,
-                `                content: "Микроструктура 1m проанализирована",`,
-                `            }`,
-                `        );`,
-                ``,
-                `        // Сообщение 5: Запрос сигнала`,
-                `        messages.push(`,
-                `            {`,
-                `                role: "user",`,
-                `                content: [`,
-                `                    "Проанализируй все таймфреймы и сгенерируй торговый сигнал согласно этой стратегии. Открывай позицию ТОЛЬКО при четком сигнале.",`,
-                `                    "",`,
-                `                    \`${escapedPrompt}\`,`,
-                `                    "",`,
-                `                    "Если сигналы противоречивы или тренд слабый то position: wait"`,
-                `                ].join("\\n"),`,
-                `            }`,
-                `        );`,
-                ``,
-                `        const resultId = uuid();`,
-                ``,
-                `        const result = await json(messages);`,
-                ``,
-                `        await dumpJson(resultId, messages, result);`,
-                ``,
-                `        result.id = resultId;`,
-                ``,
-                `        return result;`,
-                `    },`,
-                `});`
-            ].join("\n");
-        };
-        /**
-         * Generates Exchange configuration code.
-         * Uses CCXT Binance with standard formatters.
-         *
-         * @param symbol - Trading pair symbol (unused, for consistency)
-         * @param exchangeName - Unique exchange identifier
-         * @returns Generated addExchange() call with CCXT integration
-         */
-        this.getExchangeTemplate = async (symbol, exchangeName) => {
-            this.loggerService.log("optimizerTemplateService getExchangeTemplate", {
-                exchangeName,
-                symbol,
-            });
-            // Escape special characters to prevent code injection
-            const escapedExchangeName = String(exchangeName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            return [
-                `addExchangeSchema({`,
-                `    exchangeName: "${escapedExchangeName}",`,
-                `    getCandles: async (symbol, interval, since, limit) => {`,
-                `        const exchange = new ccxt.binance();`,
-                `        const ohlcv = await exchange.fetchOHLCV(symbol, interval, since.getTime(), limit);`,
-                `        return ohlcv.map(([timestamp, open, high, low, close, volume]) => ({`,
-                `            timestamp, open, high, low, close, volume`,
-                `        }));`,
-                `    },`,
-                `    formatPrice: async (symbol, price) => price.toFixed(2),`,
-                `    formatQuantity: async (symbol, quantity) => quantity.toFixed(8),`,
-                `});`
-            ].join("\n");
-        };
-        /**
-         * Generates Frame (timeframe) configuration code.
-         *
-         * @param symbol - Trading pair symbol (unused, for consistency)
-         * @param frameName - Unique frame identifier
-         * @param interval - Candle interval (e.g., "1m")
-         * @param startDate - Frame start date
-         * @param endDate - Frame end date
-         * @returns Generated addFrame() call
-         */
-        this.getFrameTemplate = async (symbol, frameName, interval, startDate, endDate) => {
-            this.loggerService.log("optimizerTemplateService getFrameTemplate", {
-                symbol,
-                frameName,
-                interval,
-                startDate,
-                endDate,
-            });
-            // Escape special characters to prevent code injection
-            const escapedFrameName = String(frameName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedInterval = String(interval)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            return [
-                `addFrameSchema({`,
-                `    frameName: "${escapedFrameName}",`,
-                `    interval: "${escapedInterval}",`,
-                `    startDate: new Date("${startDate.toISOString()}"),`,
-                `    endDate: new Date("${endDate.toISOString()}"),`,
-                `});`
-            ].join("\n");
-        };
-        /**
-         * Generates launcher code to run Walker with event listeners.
-         * Includes progress tracking and completion handlers.
-         *
-         * @param symbol - Trading pair symbol
-         * @param walkerName - Walker name to launch
-         * @returns Generated Walker.background() call with listeners
-         */
-        this.getLauncherTemplate = async (symbol, walkerName) => {
-            this.loggerService.log("optimizerTemplateService getLauncherTemplate", {
-                symbol,
-                walkerName,
-            });
-            // Escape special characters to prevent code injection
-            const escapedSymbol = String(symbol)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            const escapedWalkerName = String(walkerName)
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"');
-            return [
-                `Walker.background("${escapedSymbol}", {`,
-                `    walkerName: "${escapedWalkerName}"`,
-                `});`,
-                ``,
-                `listenSignalBacktest((event) => {`,
-                `    console.log(event);`,
-                `});`,
-                ``,
-                `listenBacktestProgress((event) => {`,
-                `    console.log(\`Progress: \${(event.progress * 100).toFixed(2)}%\`);`,
-                `    console.log(\`Processed: \${event.processedFrames} / \${event.totalFrames}\`);`,
-                `});`,
-                ``,
-                `listenWalkerProgress((event) => {`,
-                `    console.log(\`Progress: \${(event.progress * 100).toFixed(2)}%\`);`,
-                `    console.log(\`\${event.processedStrategies} / \${event.totalStrategies} strategies\`);`,
-                `    console.log(\`Walker: \${event.walkerName}, Symbol: \${event.symbol}\`);`,
-                `});`,
-                ``,
-                `listenWalkerComplete((results) => {`,
-                `    console.log("Walker completed:", results.bestStrategy);`,
-                `    Walker.dump(results.symbol, { walkerName: results.walkerName });`,
-                `});`,
-                ``,
-                `listenDoneBacktest((event) => {`,
-                `    console.log("Backtest completed:", event.symbol);`,
-                `    Backtest.dump(event.symbol, {`,
-                `        strategyName: event.strategyName,`,
-                `        exchangeName: event.exchangeName,`,
-                `        frameName: event.frameName`,
-                `    });`,
-                `});`,
-                ``,
-                `listenError((error) => {`,
-                `    console.error("Error occurred:", error);`,
-                `});`
-            ].join("\n");
-        };
-        /**
-         * Generates dumpJson() helper function for debug output.
-         * Saves LLM conversations and results to ./dump/strategy/{resultId}/
-         *
-         * @param symbol - Trading pair symbol (unused, for consistency)
-         * @returns Generated async dumpJson() function
-         */
-        this.getJsonDumpTemplate = async (symbol) => {
-            this.loggerService.log("optimizerTemplateService getJsonDumpTemplate", {
-                symbol,
-            });
-            return [
-                `async function dumpJson(resultId, history, result, 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, resultId);`,
-                ``,
-                `    try {`,
-                `        await fs.access(subfolderPath);`,
-                `        return;`,
-                `    } catch {`,
-                `        await fs.mkdir(subfolderPath, { recursive: true });`,
-                `    }`,
-                ``,
-                `    {`,
-                `        let summary = "# Outline Result Summary\\n\\n";`,
-                ``,
-                `        {`,
-                `            summary += \`**ResultId**: \${resultId}\\n\\n\`;`,
-                `        }`,
-                ``,
-                `        if (result) {`,
-                `            summary += "## Output Data\\n\\n";`,
-                `            summary += "\`\`\`json\\n";`,
-                `            summary += JSON.stringify(result, 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\\n";`,
-                `            });`,
-                `        }`,
-                ``,
-                `        const summaryFile = path.join(subfolderPath, "00_system_prompt.md");`,
-                `        await fs.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**: \${resultId}\\n\\n\`;`,
-                `                content += message.content;`,
-                `                content += "\\n";`,
-                ``,
-                `                await fs.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**: \${resultId}\\n\\n\`;`,
-                ``,
-                `        if (result) {`,
-                `            content += "## Output Data\\n\\n";`,
-                `            content += "\`\`\`json\\n";`,
-                `            content += JSON.stringify(result, null, 2);`,
-                `            content += "\\n\`\`\`\\n";`,
-                `        }`,
-                ``,
-                `        await fs.writeFile(contentFilePath, content, "utf8");`,
-                `    }`,
-                `}`
-            ].join("\n");
+const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, backtest, when, self) => {
+    if (self._states === NEED_FETCH$1) {
+        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 = {
+            profitLevels: new Set(),
+            lossLevels: new Set(),
         };
-        /**
-         * Generates text() helper for LLM text generation.
-         * Uses Ollama deepseek-v3.1:671b model for market analysis.
-         *
-         * @param symbol - Trading pair symbol (used in prompt)
-         * @returns Generated async text() function
-         */
-        this.getTextTemplate = async (symbol) => {
-            this.loggerService.log("optimizerTemplateService getTextTemplate", {
+        self._states.set(data.id, state);
+    }
+    let shouldPersist = false;
+    for (const level of PROFIT_LEVELS) {
+        if (revenuePercent >= level && !state.profitLevels.has(level)) {
+            state.profitLevels.add(level);
+            shouldPersist = true;
+            self.params.logger.debug("ClientPartial profit level reached", {
                 symbol,
+                signalId: data.id,
+                level,
+                revenuePercent,
+                backtest,
             });
-            // Escape special characters in symbol to prevent code injection
-            const escapedSymbol = String(symbol)
-                .replace(/\\/g, '\\\\')
-                .replace(/`/g, '\\`')
-                .replace(/\$/g, '\\$')
-                .toUpperCase();
-            return [
-                `async function text(messages) {`,
-                `    const ollama = new Ollama({`,
-                `        host: "https://ollama.com",`,
-                `        headers: {`,
-                `            Authorization: \`Bearer \${process.env.OLLAMA_API_KEY}\`,`,
-                `        },`,
-                `    });`,
-                ``,
-                `    const response = await ollama.chat({`,
-                `        model: "deepseek-v3.1:671b",`,
-                `        messages: [`,
-                `            {`,
-                `                role: "system",`,
-                `                content: [`,
-                `                    "В ответ напиши торговую стратегию где нет ничего лишнего,",`,
-                `                    "только отчёт готовый для копипасты целиком",`,
-                `                    "",`,
-                `                    "**ВАЖНО**: Не здоровайся, не говори что делаешь - только отчёт!"`,
-                `                ].join("\\n"),`,
-                `            },`,
-                `            ...messages,`,
-                `            {`,
-                `                role: "user",`,
-                `                content: [`,
-                `                    "На каких условиях мне купить ${escapedSymbol}?",`,
-                `                    "Дай анализ рынка на основе поддержки/сопротивления, точек входа в LONG/SHORT позиции.",`,
-                `                    "Какой RR ставить для позиций?",`,
-                `                    "Предпочтительны LONG или SHORT позиции?",`,
-                `                    "",`,
-                `                    "Сделай не сухой технический, а фундаментальный анализ, содержащий стратигическую рекомендацию, например, покупать на низу боковика"`,
-                `                ].join("\\n")`,
-                `            }`,
-                `        ]`,
-                `    });`,
-                ``,
-                `    const content = response.message.content.trim();`,
-                `    return content`,
-                `        .replace(/\\\\/g, '\\\\\\\\')`,
-                `        .replace(/\`/g, '\\\\\`')`,
-                `        .replace(/\\$/g, '\\\\$')`,
-                `        .replace(/"/g, '\\\\"')`,
-                `        .replace(/'/g, "\\\\'");`,
-                `}`
-            ].join("\n");
+            await self.params.onProfit(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, level, backtest, when.getTime());
+        }
+    }
+    if (shouldPersist) {
+        await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
+    }
+};
+/**
+ * Internal loss handler function for ClientPartial.
+ *
+ * Checks which loss levels have been reached and emits events for new levels only.
+ * Uses Set-based deduplication to prevent duplicate events.
+ * Converts negative lossPercent to absolute value for level comparison.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Signal row data
+ * @param currentPrice - Current market price
+ * @param lossPercent - Current loss percentage (negative value)
+ * @param backtest - True if backtest mode
+ * @param when - Event timestamp
+ * @param self - ClientPartial instance reference
+ */
+const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest, when, self) => {
+    if (self._states === NEED_FETCH$1) {
+        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 = {
+            profitLevels: new Set(),
+            lossLevels: new Set(),
         };
-        /**
-         * Generates json() helper for structured LLM output.
-         * Uses Ollama with JSON schema for trading signals.
-         *
-         * Signal schema:
-         * - position: "wait" | "long" | "short"
-         * - note: strategy explanation
-         * - priceOpen: entry price
-         * - priceTakeProfit: target price
-         * - priceStopLoss: stop price
-         * - minuteEstimatedTime: expected duration (max 360 min)
-         *
-         * @param symbol - Trading pair symbol (unused, for consistency)
-         * @returns Generated async json() function with signal schema
-         */
-        this.getJsonTemplate = async (symbol) => {
-            this.loggerService.log("optimizerTemplateService getJsonTemplate", {
+        self._states.set(data.id, state);
+    }
+    const absLoss = Math.abs(lossPercent);
+    let shouldPersist = false;
+    for (const level of LOSS_LEVELS) {
+        if (absLoss >= level && !state.lossLevels.has(level)) {
+            state.lossLevels.add(level);
+            shouldPersist = true;
+            self.params.logger.debug("ClientPartial loss level reached", {
                 symbol,
+                signalId: data.id,
+                level,
+                lossPercent,
+                backtest,
             });
-            return [
-                `async function json(messages) {`,
-                `    const ollama = new Ollama({`,
-                `        host: "https://ollama.com",`,
-                `        headers: {`,
-                `            Authorization: \`Bearer \${process.env.OLLAMA_API_KEY}\`,`,
-                `        },`,
-                `    });`,
-                ``,
-                `    const response = await ollama.chat({`,
-                `        model: "deepseek-v3.1:671b",`,
-                `        messages: [`,
-                `            {`,
-                `                role: "system",`,
-                `                content: [`,
-                `                    "Проанализируй торговую стратегию и верни торговый сигнал.",`,
-                `                    "",`,
-                `                    "ПРАВИЛА ОТКРЫТИЯ ПОЗИЦИЙ:",`,
-                `                    "",`,
-                `                    "1. ТИПЫ ПОЗИЦИЙ:",`,
-                `                    "   - position='wait': нет четкого сигнала, жди лучших условий",`,
-                `                    "   - position='long': бычий сигнал, цена будет расти",`,
-                `                    "   - position='short': медвежий сигнал, цена будет падать",`,
-                `                    "",`,
-                `                    "2. ЦЕНА ВХОДА (priceOpen):",`,
-                `                    "   - Может быть текущей рыночной ценой для немедленного входа",`,
-                `                    "   - Может быть отложенной ценой для входа при достижении уровня",`,
-                `                    "   - Укажи оптимальную цену входа согласно технического анализа",`,
-                `                    "",`,
-                `                    "3. УРОВНИ ВЫХОДА:",`,
-                `                    "   - LONG: priceTakeProfit > priceOpen > priceStopLoss",`,
-                `                    "   - SHORT: priceStopLoss > priceOpen > priceTakeProfit",`,
-                `                    "   - Уровни должны иметь техническое обоснование (Fibonacci, S/R, Bollinger)",`,
-                `                    "",`,
-                `                    "4. ВРЕМЕННЫЕ РАМКИ:",`,
-                `                    "   - minuteEstimatedTime: прогноз времени до TP (макс 360 минут)",`,
-                `                    "   - Расчет на основе ATR, ADX, MACD, Momentum, Slope",`,
-                `                    "   - Если индикаторов, осциллятор или других метрик нет, посчитай их самостоятельно",`,
-                `                ].join("\\n"),`,
-                `            },`,
-                `            ...messages,`,
-                `        ],`,
-                `        format: {`,
-                `            type: "object",`,
-                `            properties: {`,
-                `                position: {`,
-                `                    type: "string",`,
-                `                    enum: ["wait", "long", "short"],`,
-                `                    description: "Trade decision: wait (no signal), long (buy), or short (sell)",`,
-                `                },`,
-                `                note: {`,
-                `                    type: "string",`,
-                `                    description: "Professional trading recommendation with price levels",`,
-                `                },`,
-                `                priceOpen: {`,
-                `                    type: "number",`,
-                `                    description: "Entry price (current market price or limit order price)",`,
-                `                },`,
-                `                priceTakeProfit: {`,
-                `                    type: "number",`,
-                `                    description: "Take profit target price",`,
-                `                },`,
-                `                priceStopLoss: {`,
-                `                    type: "number",`,
-                `                    description: "Stop loss exit price",`,
-                `                },`,
-                `                minuteEstimatedTime: {`,
-                `                    type: "number",`,
-                `                    description: "Expected time to reach TP in minutes (max 360)",`,
-                `                },`,
-                `            },`,
-                `            required: ["position", "note", "priceOpen", "priceTakeProfit", "priceStopLoss", "minuteEstimatedTime"],`,
-                `        },`,
-                `    });`,
-                ``,
-                `    const jsonResponse = JSON.parse(response.message.content.trim());`,
-                `    return jsonResponse;`,
-                `}`
-            ].join("\n");
-        };
+            await self.params.onLoss(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, level, backtest, when.getTime());
+        }
     }
-}
-
+    if (shouldPersist) {
+        await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
+    }
+};
 /**
- * Service for managing optimizer schema registration and retrieval.
- * Provides validation and registry management for optimizer configurations.
- *
- * Uses ToolRegistry for immutable schema storage.
- */
-class OptimizerSchemaService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this._registry = new ToolRegistry("optimizerSchema");
-        /**
-         * Registers a new optimizer schema.
-         * Validates required fields before registration.
-         *
-         * @param key - Unique optimizer name
-         * @param value - Optimizer schema configuration
-         * @throws Error if schema validation fails
-         */
-        this.register = (key, value) => {
-            this.loggerService.log(`optimizerSchemaService register`, { key });
-            this.validateShallow(value);
-            this._registry = this._registry.register(key, value);
-        };
-        /**
-         * Validates optimizer schema structure.
-         * Checks required fields: optimizerName, rangeTrain, source, getPrompt.
-         *
-         * @param optimizerSchema - Schema to validate
-         * @throws Error if validation fails
-         */
-        this.validateShallow = (optimizerSchema) => {
-            this.loggerService.log(`optimizerTemplateService validateShallow`, {
-                optimizerSchema,
-            });
-            if (typeof optimizerSchema.optimizerName !== "string") {
-                throw new Error(`optimizer template validation failed: missing optimizerName`);
-            }
-            if (!Array.isArray(optimizerSchema.rangeTrain) || optimizerSchema.rangeTrain.length === 0) {
-                throw new Error(`optimizer template validation failed: rangeTrain must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
-            }
-            if (!Array.isArray(optimizerSchema.source) || optimizerSchema.source.length === 0) {
-                throw new Error(`optimizer template validation failed: source must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
-            }
-            if (typeof optimizerSchema.getPrompt !== "function") {
-                throw new Error(`optimizer template validation failed: getPrompt must be a function for optimizerName=${optimizerSchema.optimizerName}`);
-            }
-        };
-        /**
-         * Partially overrides an existing optimizer schema.
-         * Merges provided values with existing schema.
-         *
-         * @param key - Optimizer name to override
-         * @param value - Partial schema values to merge
-         * @returns Updated complete schema
-         * @throws Error if optimizer not found
-         */
-        this.override = (key, value) => {
-            this.loggerService.log(`optimizerSchemaService override`, { key });
-            this._registry = this._registry.override(key, value);
-            return this._registry.get(key);
-        };
-        /**
-         * Retrieves optimizer schema by name.
-         *
-         * @param key - Optimizer name
-         * @returns Complete optimizer schema
-         * @throws Error if optimizer not found
-         */
-        this.get = (key) => {
-            this.loggerService.log(`optimizerSchemaService get`, { key });
-            return this._registry.get(key);
-        };
-    }
-}
-
-/**
- * Service for validating optimizer existence and managing optimizer registry.
- * Maintains a Map of registered optimizers for validation purposes.
- *
- * Uses memoization for efficient repeated validation checks.
- */
-class OptimizerValidationService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this._optimizerMap = new Map();
-        /**
-         * Adds optimizer to validation registry.
-         * Prevents duplicate optimizer names.
-         *
-         * @param optimizerName - Unique optimizer identifier
-         * @param optimizerSchema - Complete optimizer schema
-         * @throws Error if optimizer with same name already exists
-         */
-        this.addOptimizer = (optimizerName, optimizerSchema) => {
-            this.loggerService.log("optimizerValidationService addOptimizer", {
-                optimizerName,
-                optimizerSchema,
-            });
-            if (this._optimizerMap.has(optimizerName)) {
-                throw new Error(`optimizer ${optimizerName} already exist`);
-            }
-            this._optimizerMap.set(optimizerName, optimizerSchema);
-        };
-        /**
-         * Validates that optimizer exists in registry.
-         * Memoized for performance on repeated checks.
-         *
-         * @param optimizerName - Optimizer name to validate
-         * @param source - Source method name for error messages
-         * @throws Error if optimizer not found
-         */
-        this.validate = memoize(([optimizerName]) => optimizerName, (optimizerName, source) => {
-            this.loggerService.log("optimizerValidationService validate", {
-                optimizerName,
-                source,
-            });
-            const optimizer = this._optimizerMap.get(optimizerName);
-            if (!optimizer) {
-                throw new Error(`optimizer ${optimizerName} not found source=${source}`);
-            }
-            return true;
-        });
-        /**
-         * Lists all registered optimizer schemas.
-         *
-         * @returns Array of all optimizer schemas
-         */
-        this.list = async () => {
-            this.loggerService.log("optimizerValidationService list");
-            return Array.from(this._optimizerMap.values());
-        };
-    }
-}
-
-const METHOD_NAME_GET_DATA = "optimizerGlobalService getData";
-const METHOD_NAME_GET_CODE = "optimizerGlobalService getCode";
-const METHOD_NAME_DUMP = "optimizerGlobalService dump";
-/**
- * Global service for optimizer operations with validation.
- * Entry point for public API, performs validation before delegating to ConnectionService.
- *
- * Workflow:
- * 1. Log operation
- * 2. Validate optimizer exists
- * 3. Delegate to OptimizerConnectionService
- */
-class OptimizerGlobalService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this.optimizerConnectionService = inject(TYPES.optimizerConnectionService);
-        this.optimizerValidationService = inject(TYPES.optimizerValidationService);
-        /**
-         * Fetches data from all sources and generates strategy metadata.
-         * Validates optimizer existence before execution.
-         *
-         * @param symbol - Trading pair symbol
-         * @param optimizerName - Optimizer identifier
-         * @returns Array of generated strategies with conversation context
-         * @throws Error if optimizer not found
-         */
-        this.getData = async (symbol, optimizerName) => {
-            this.loggerService.log(METHOD_NAME_GET_DATA, {
-                symbol,
-                optimizerName,
-            });
-            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_DATA);
-            return await this.optimizerConnectionService.getData(symbol, optimizerName);
-        };
-        /**
-         * Generates complete executable strategy code.
-         * Validates optimizer existence before execution.
-         *
-         * @param symbol - Trading pair symbol
-         * @param optimizerName - Optimizer identifier
-         * @returns Generated TypeScript/JavaScript code as string
-         * @throws Error if optimizer not found
-         */
-        this.getCode = async (symbol, optimizerName) => {
-            this.loggerService.log(METHOD_NAME_GET_CODE, {
-                symbol,
-                optimizerName,
-            });
-            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_CODE);
-            return await this.optimizerConnectionService.getCode(symbol, optimizerName);
-        };
-        /**
-         * Generates and saves strategy code to file.
-         * Validates optimizer existence before execution.
-         *
-         * @param symbol - Trading pair symbol
-         * @param optimizerName - Optimizer identifier
-         * @param path - Output directory path (optional)
-         * @throws Error if optimizer not found
-         */
-        this.dump = async (symbol, optimizerName, path) => {
-            this.loggerService.log(METHOD_NAME_DUMP, {
-                symbol,
-                optimizerName,
-                path,
-            });
-            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_DUMP);
-            return await this.optimizerConnectionService.dump(symbol, optimizerName, path);
-        };
-    }
-}
-
-const ITERATION_LIMIT = 25;
-const DEFAULT_SOURCE_NAME = "unknown";
-const CREATE_PREFIX_FN = () => (Math.random() + 1).toString(36).substring(7);
-/**
- * Wrapper to call onSourceData callback with error handling.
- * Catches and logs any errors thrown by the user-provided callback.
- */
-const CALL_SOURCE_DATA_CALLBACKS_FN = trycatch(async (self, symbol, name, data, startDate, endDate) => {
-    if (self.params.callbacks?.onSourceData) {
-        await self.params.callbacks.onSourceData(symbol, name, data, startDate, endDate);
-    }
-}, {
-    fallback: (error) => {
-        const message = "ClientOptimizer CALL_SOURCE_DATA_CALLBACKS_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-});
-/**
- * Wrapper to call onData callback with error handling.
- * Catches and logs any errors thrown by the user-provided callback.
- */
-const CALL_DATA_CALLBACKS_FN = trycatch(async (self, symbol, strategyList) => {
-    if (self.params.callbacks?.onData) {
-        await self.params.callbacks.onData(symbol, strategyList);
-    }
-}, {
-    fallback: (error) => {
-        const message = "ClientOptimizer CALL_DATA_CALLBACKS_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-});
-/**
- * Wrapper to call onCode callback with error handling.
- * Catches and logs any errors thrown by the user-provided callback.
- */
-const CALL_CODE_CALLBACKS_FN = trycatch(async (self, symbol, code) => {
-    if (self.params.callbacks?.onCode) {
-        await self.params.callbacks.onCode(symbol, code);
-    }
-}, {
-    fallback: (error) => {
-        const message = "ClientOptimizer CALL_CODE_CALLBACKS_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-});
-/**
- * Wrapper to call onDump callback with error handling.
- * Catches and logs any errors thrown by the user-provided callback.
- */
-const CALL_DUMP_CALLBACKS_FN = trycatch(async (self, symbol, filepath) => {
-    if (self.params.callbacks?.onDump) {
-        await self.params.callbacks.onDump(symbol, filepath);
-    }
-}, {
-    fallback: (error) => {
-        const message = "ClientOptimizer CALL_DUMP_CALLBACKS_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-});
-/**
- * Default user message formatter.
- * Delegates to template's getUserMessage method.
- *
- * @param symbol - Trading pair symbol
- * @param data - Fetched data array
- * @param name - Source name
- * @param self - ClientOptimizer instance
- * @returns Formatted user message content
- */
-const DEFAULT_USER_FN = async (symbol, data, name, self) => {
-    return await self.params.template.getUserMessage(symbol, data, name);
-};
-/**
- * Default assistant message formatter.
- * Delegates to template's getAssistantMessage method.
- *
- * @param symbol - Trading pair symbol
- * @param data - Fetched data array
- * @param name - Source name
- * @param self - ClientOptimizer instance
- * @returns Formatted assistant message content
- */
-const DEFAULT_ASSISTANT_FN = async (symbol, data, name, self) => {
-    return await self.params.template.getAssistantMessage(symbol, data, name);
-};
-/**
- * Resolves paginated data from source with deduplication.
- * Uses iterateDocuments to handle pagination automatically.
- *
- * @param fetch - Source fetch function
- * @param filterData - Filter arguments (symbol, dates)
- * @returns Deduplicated array of all fetched data
- */
-const RESOLVE_PAGINATION_FN = async (fetch, filterData) => {
-    const iterator = iterateDocuments({
-        limit: ITERATION_LIMIT,
-        async createRequest({ limit, offset }) {
-            return await fetch({
-                symbol: filterData.symbol,
-                startDate: filterData.startDate,
-                endDate: filterData.endDate,
-                limit,
-                offset,
-            });
-        },
-    });
-    const distinct = distinctDocuments(iterator, (data) => data.id);
-    return await resolveDocuments(distinct);
-};
-/**
- * Collects data from all sources and generates strategy metadata.
- * Iterates through training ranges, fetches data from each source,
- * builds LLM conversation history, and generates strategy prompts.
- *
- * @param symbol - Trading pair symbol
- * @param self - ClientOptimizer instance
- * @returns Array of generated strategies with conversation context
- */
-const GET_STRATEGY_DATA_FN = async (symbol, self) => {
-    const strategyList = [];
-    const totalSources = self.params.rangeTrain.length * self.params.source.length;
-    let processedSources = 0;
-    for (const { startDate, endDate } of self.params.rangeTrain) {
-        const messageList = [];
-        for (const source of self.params.source) {
-            // Emit progress event at the start of processing each source
-            await self.onProgress({
-                optimizerName: self.params.optimizerName,
-                symbol,
-                totalSources,
-                processedSources,
-                progress: totalSources > 0 ? processedSources / totalSources : 0,
-            });
-            if (typeof source === "function") {
-                const data = await RESOLVE_PAGINATION_FN(source, {
-                    symbol,
-                    startDate,
-                    endDate,
-                });
-                await CALL_SOURCE_DATA_CALLBACKS_FN(self, symbol, DEFAULT_SOURCE_NAME, data, startDate, endDate);
-                const [userContent, assistantContent] = await Promise.all([
-                    DEFAULT_USER_FN(symbol, data, DEFAULT_SOURCE_NAME, self),
-                    DEFAULT_ASSISTANT_FN(symbol, data, DEFAULT_SOURCE_NAME, self),
-                ]);
-                messageList.push({
-                    role: "user",
-                    content: userContent,
-                }, {
-                    role: "assistant",
-                    content: assistantContent,
-                });
-                processedSources++;
-            }
-            else {
-                const { fetch, name = DEFAULT_SOURCE_NAME, assistant = DEFAULT_ASSISTANT_FN, user = DEFAULT_USER_FN, } = source;
-                const data = await RESOLVE_PAGINATION_FN(fetch, {
-                    symbol,
-                    startDate,
-                    endDate,
-                });
-                await CALL_SOURCE_DATA_CALLBACKS_FN(self, symbol, name, data, startDate, endDate);
-                const [userContent, assistantContent] = await Promise.all([
-                    user(symbol, data, name, self),
-                    assistant(symbol, data, name, self),
-                ]);
-                messageList.push({
-                    role: "user",
-                    content: userContent,
-                }, {
-                    role: "assistant",
-                    content: assistantContent,
-                });
-                processedSources++;
-            }
-            const name = "name" in source
-                ? source.name || DEFAULT_SOURCE_NAME
-                : DEFAULT_SOURCE_NAME;
-            strategyList.push({
-                symbol,
-                name,
-                messages: messageList,
-                strategy: await self.params.getPrompt(symbol, messageList),
-            });
-        }
-    }
-    // Emit final progress event (100%)
-    await self.onProgress({
-        optimizerName: self.params.optimizerName,
-        symbol,
-        totalSources,
-        processedSources: totalSources,
-        progress: 1.0,
-    });
-    await CALL_DATA_CALLBACKS_FN(self, symbol, strategyList);
-    return strategyList;
-};
-/**
- * Generates complete executable strategy code.
- * Assembles all components: imports, helpers, exchange, frames, strategies, walker, launcher.
- *
- * @param symbol - Trading pair symbol
- * @param self - ClientOptimizer instance
- * @returns Generated TypeScript/JavaScript code as string
- */
-const GET_STRATEGY_CODE_FN = async (symbol, self) => {
-    const strategyData = await self.getData(symbol);
-    const prefix = CREATE_PREFIX_FN();
-    const sections = [];
-    const exchangeName = `${prefix}_exchange`;
-    // 1. Top banner with imports
-    {
-        sections.push(await self.params.template.getTopBanner(symbol));
-        sections.push("");
-    }
-    // 2. JSON dump helper function
-    {
-        sections.push(await self.params.template.getJsonDumpTemplate(symbol));
-        sections.push("");
-    }
-    // 3. Helper functions (text and json)
-    {
-        sections.push(await self.params.template.getTextTemplate(symbol));
-        sections.push("");
-    }
-    {
-        sections.push(await self.params.template.getJsonTemplate(symbol));
-        sections.push("");
-    }
-    // 4. Exchange template (assuming first strategy has exchange info)
-    {
-        sections.push(await self.params.template.getExchangeTemplate(symbol, exchangeName));
-        sections.push("");
-    }
-    // 5. Train frame templates
-    {
-        for (let i = 0; i < self.params.rangeTrain.length; i++) {
-            const range = self.params.rangeTrain[i];
-            const frameName = `${prefix}_train_frame-${i + 1}`;
-            sections.push(await self.params.template.getFrameTemplate(symbol, frameName, "1m", // default interval
-            range.startDate, range.endDate));
-            sections.push("");
-        }
-    }
-    // 6. Test frame template
-    {
-        const testFrameName = `${prefix}_test_frame`;
-        sections.push(await self.params.template.getFrameTemplate(symbol, testFrameName, "1m", // default interval
-        self.params.rangeTest.startDate, self.params.rangeTest.endDate));
-        sections.push("");
-    }
-    // 7. Strategy templates for each generated strategy
-    {
-        for (let i = 0; i < strategyData.length; i++) {
-            const strategy = strategyData[i];
-            const strategyName = `${prefix}_strategy-${i + 1}`;
-            const interval = "5m"; // default interval
-            sections.push(await self.params.template.getStrategyTemplate(strategyName, interval, strategy.strategy));
-            sections.push("");
-        }
-    }
-    // 8. Walker template (uses test frame for validation)
-    {
-        const walkerName = `${prefix}_walker`;
-        const testFrameName = `${prefix}_test_frame`;
-        const strategies = strategyData.map((_, i) => `${prefix}_strategy-${i + 1}`);
-        sections.push(await self.params.template.getWalkerTemplate(walkerName, `${exchangeName}`, testFrameName, strategies));
-        sections.push("");
-    }
-    // 9. Launcher template
-    {
-        const walkerName = `${prefix}_walker`;
-        sections.push(await self.params.template.getLauncherTemplate(symbol, walkerName));
-        sections.push("");
-    }
-    const code = sections.join("\n");
-    await CALL_CODE_CALLBACKS_FN(self, symbol, code);
-    return code;
-};
-/**
- * Saves generated strategy code to file.
- * Creates directory if needed, writes .mjs file with generated code.
- *
- * @param symbol - Trading pair symbol
- * @param path - Output directory path
- * @param self - ClientOptimizer instance
- */
-const GET_STRATEGY_DUMP_FN = async (symbol, path, self) => {
-    const report = await self.getCode(symbol);
-    try {
-        const dir = join(process.cwd(), path);
-        await mkdir(dir, { recursive: true });
-        const filename = `${self.params.optimizerName}_${symbol}.mjs`;
-        const filepath = join(dir, filename);
-        await writeFile(filepath, report, "utf-8");
-        self.params.logger.info(`Optimizer report saved: ${filepath}`);
-        await CALL_DUMP_CALLBACKS_FN(self, symbol, filepath);
-    }
-    catch (error) {
-        self.params.logger.warn(`Failed to save optimizer report:`, error);
-        throw error;
-    }
-};
-/**
- * Client implementation for optimizer operations.
- *
- * Features:
- * - Data collection from multiple sources with pagination
- * - LLM conversation history building
- * - Strategy code generation with templates
- * - File export with callbacks
- *
- * Used by OptimizerConnectionService to create optimizer instances.
- */
-class ClientOptimizer {
-    constructor(params, onProgress) {
-        this.params = params;
-        this.onProgress = onProgress;
-        /**
-         * Fetches data from all sources and generates strategy metadata.
-         * Processes each training range and builds LLM conversation history.
-         *
-         * @param symbol - Trading pair symbol
-         * @returns Array of generated strategies with conversation context
-         */
-        this.getData = async (symbol) => {
-            this.params.logger.debug("ClientOptimizer getData", {
-                symbol,
-            });
-            return await GET_STRATEGY_DATA_FN(symbol, this);
-        };
-        /**
-         * Generates complete executable strategy code.
-         * Includes imports, helpers, strategies, walker, and launcher.
-         *
-         * @param symbol - Trading pair symbol
-         * @returns Generated TypeScript/JavaScript code as string
-         */
-        this.getCode = async (symbol) => {
-            this.params.logger.debug("ClientOptimizer getCode", {
-                symbol,
-            });
-            return await GET_STRATEGY_CODE_FN(symbol, this);
-        };
-        /**
-         * Generates and saves strategy code to file.
-         * Creates directory if needed, writes .mjs file.
-         *
-         * @param symbol - Trading pair symbol
-         * @param path - Output directory path (default: "./")
-         */
-        this.dump = async (symbol, path = "./") => {
-            this.params.logger.debug("ClientOptimizer dump", {
-                symbol,
-                path,
-            });
-            return await GET_STRATEGY_DUMP_FN(symbol, path, this);
-        };
-    }
-}
-
-/**
- * Callback function for emitting progress events to progressOptimizerEmitter.
- */
-const COMMIT_PROGRESS_FN = async (progress) => progressOptimizerEmitter.next(progress);
-/**
- * Service for creating and caching optimizer client instances.
- * Handles dependency injection and template merging.
- *
- * Features:
- * - Memoized optimizer instances (one per optimizerName)
- * - Template merging (custom + defaults)
- * - Logger injection
- * - Delegates to ClientOptimizer for actual operations
- */
-class OptimizerConnectionService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this.optimizerSchemaService = inject(TYPES.optimizerSchemaService);
-        this.optimizerTemplateService = inject(TYPES.optimizerTemplateService);
-        /**
-         * Creates or retrieves cached optimizer instance.
-         * Memoized by optimizerName for performance.
-         *
-         * Merges custom templates from schema with defaults from OptimizerTemplateService.
-         *
-         * @param optimizerName - Unique optimizer identifier
-         * @returns ClientOptimizer instance with resolved dependencies
-         */
-        this.getOptimizer = memoize(([optimizerName]) => `${optimizerName}`, (optimizerName) => {
-            const { getPrompt, rangeTest, rangeTrain, source, template: rawTemplate = {}, callbacks, } = this.optimizerSchemaService.get(optimizerName);
-            const { getAssistantMessage = this.optimizerTemplateService.getAssistantMessage, getExchangeTemplate = this.optimizerTemplateService.getExchangeTemplate, getFrameTemplate = this.optimizerTemplateService.getFrameTemplate, getJsonDumpTemplate = this.optimizerTemplateService.getJsonDumpTemplate, getJsonTemplate = this.optimizerTemplateService.getJsonTemplate, getLauncherTemplate = this.optimizerTemplateService.getLauncherTemplate, getStrategyTemplate = this.optimizerTemplateService.getStrategyTemplate, getTextTemplate = this.optimizerTemplateService.getTextTemplate, getWalkerTemplate = this.optimizerTemplateService.getWalkerTemplate, getTopBanner = this.optimizerTemplateService.getTopBanner, getUserMessage = this.optimizerTemplateService.getUserMessage, } = rawTemplate;
-            const template = {
-                getAssistantMessage,
-                getExchangeTemplate,
-                getFrameTemplate,
-                getJsonDumpTemplate,
-                getJsonTemplate,
-                getLauncherTemplate,
-                getStrategyTemplate,
-                getTextTemplate,
-                getWalkerTemplate,
-                getTopBanner,
-                getUserMessage,
-            };
-            return new ClientOptimizer({
-                optimizerName,
-                logger: this.loggerService,
-                getPrompt,
-                rangeTest,
-                rangeTrain,
-                source,
-                template,
-                callbacks,
-            }, COMMIT_PROGRESS_FN);
-        });
-        /**
-         * Fetches data from all sources and generates strategy metadata.
-         *
-         * @param symbol - Trading pair symbol
-         * @param optimizerName - Optimizer identifier
-         * @returns Array of generated strategies with conversation context
-         */
-        this.getData = async (symbol, optimizerName) => {
-            this.loggerService.log("optimizerConnectionService getData", {
-                symbol,
-                optimizerName,
-            });
-            const optimizer = this.getOptimizer(optimizerName);
-            return await optimizer.getData(symbol);
-        };
-        /**
-         * Generates complete executable strategy code.
-         *
-         * @param symbol - Trading pair symbol
-         * @param optimizerName - Optimizer identifier
-         * @returns Generated TypeScript/JavaScript code as string
-         */
-        this.getCode = async (symbol, optimizerName) => {
-            this.loggerService.log("optimizerConnectionService getCode", {
-                symbol,
-                optimizerName,
-            });
-            const optimizer = this.getOptimizer(optimizerName);
-            return await optimizer.getCode(symbol);
-        };
-        /**
-         * Generates and saves strategy code to file.
-         *
-         * @param symbol - Trading pair symbol
-         * @param optimizerName - Optimizer identifier
-         * @param path - Output directory path (optional)
-         */
-        this.dump = async (symbol, optimizerName, path) => {
-            this.loggerService.log("optimizerConnectionService getCode", {
-                symbol,
-                optimizerName,
-            });
-            const optimizer = this.getOptimizer(optimizerName);
-            return await optimizer.dump(symbol, path);
-        };
-    }
-}
-
-/**
- * Symbol marker indicating that partial state needs initialization.
- * Used as sentinel value for _states before waitForInit() is called.
- */
-const NEED_FETCH$1 = Symbol("need_fetch");
-/**
- * Array of profit level milestones to track (10%, 20%, ..., 100%).
- * Each level is checked during profit() method to emit events for newly reached levels.
- */
-const PROFIT_LEVELS = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
-/**
- * Array of loss level milestones to track (-10%, -20%, ..., -100%).
- * Each level is checked during loss() method to emit events for newly reached levels.
- */
-const LOSS_LEVELS = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
-/**
- * Internal profit handler function for ClientPartial.
- *
- * Checks which profit levels have been reached and emits events for new levels only.
- * Uses Set-based deduplication to prevent duplicate events.
- *
- * @param symbol - Trading pair symbol
- * @param data - Signal row data
- * @param currentPrice - Current market price
- * @param revenuePercent - Current profit percentage (positive value)
- * @param backtest - True if backtest mode
- * @param when - Event timestamp
- * @param self - ClientPartial instance reference
- */
-const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, backtest, when, self) => {
-    if (self._states === NEED_FETCH$1) {
-        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 = {
-            profitLevels: new Set(),
-            lossLevels: new Set(),
-        };
-        self._states.set(data.id, state);
-    }
-    let shouldPersist = false;
-    for (const level of PROFIT_LEVELS) {
-        if (revenuePercent >= level && !state.profitLevels.has(level)) {
-            state.profitLevels.add(level);
-            shouldPersist = true;
-            self.params.logger.debug("ClientPartial profit level reached", {
-                symbol,
-                signalId: data.id,
-                level,
-                revenuePercent,
-                backtest,
-            });
-            await self.params.onProfit(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, level, backtest, when.getTime());
-        }
-    }
-    if (shouldPersist) {
-        await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
-    }
-};
-/**
- * Internal loss handler function for ClientPartial.
- *
- * Checks which loss levels have been reached and emits events for new levels only.
- * Uses Set-based deduplication to prevent duplicate events.
- * Converts negative lossPercent to absolute value for level comparison.
- *
- * @param symbol - Trading pair symbol
- * @param data - Signal row data
- * @param currentPrice - Current market price
- * @param lossPercent - Current loss percentage (negative value)
- * @param backtest - True if backtest mode
- * @param when - Event timestamp
- * @param self - ClientPartial instance reference
- */
-const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest, when, self) => {
-    if (self._states === NEED_FETCH$1) {
-        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 = {
-            profitLevels: new Set(),
-            lossLevels: new Set(),
-        };
-        self._states.set(data.id, state);
-    }
-    const absLoss = Math.abs(lossPercent);
-    let shouldPersist = false;
-    for (const level of LOSS_LEVELS) {
-        if (absLoss >= level && !state.lossLevels.has(level)) {
-            state.lossLevels.add(level);
-            shouldPersist = true;
-            self.params.logger.debug("ClientPartial loss level reached", {
-                symbol,
-                signalId: data.id,
-                level,
-                lossPercent,
-                backtest,
-            });
-            await self.params.onLoss(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, level, backtest, when.getTime());
-        }
-    }
-    if (shouldPersist) {
-        await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
-    }
-};
-/**
- * Internal initialization function for ClientPartial.
+ * Internal initialization function for ClientPartial.
  *
  * Loads persisted partial state from disk and restores in-memory Maps.
  * Converts serialized arrays back to Sets for O(1) lookups.
@@ -21989,162 +20677,6 @@ class BreakevenGlobalService {
     }
 }
 
-/**
- * Warning threshold for message size in kilobytes.
- * Messages exceeding this size trigger console warnings.
- */
-const WARN_KB = 30;
-/**
- * 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/outline") => {
-    // 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));
-    // Generate system prompt markdown
-    {
-        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";
-            });
-        }
-        await Markdown.writeData("outline", summary, {
-            path: subfolderPath,
-            file: "00_system_prompt.md",
-            symbol: "",
-            signalId: String(signalId),
-            strategyName: "",
-            exchangeName: "",
-            frameName: ""
-        });
-    }
-    // Generate user messages
-    {
-        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 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 Markdown.writeData("outline", content, {
-                path: subfolderPath,
-                file: contentFileName,
-                signalId: String(signalId),
-                symbol: "",
-                strategyName: "",
-                exchangeName: "",
-                frameName: ""
-            });
-        }));
-    }
-    // Generate LLM output
-    {
-        const messageNum = String(userMessages.length + 1).padStart(2, "0");
-        const contentFileName = `${messageNum}_llm_output.md`;
-        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 Markdown.writeData("outline", content, {
-            path: subfolderPath,
-            file: contentFileName,
-            symbol: "",
-            signalId: String(signalId),
-            strategyName: "",
-            exchangeName: "",
-            frameName: ""
-        });
-    }
-};
-/**
- * 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);
-        };
-    }
-}
-
 /**
  * Service for validating GLOBAL_CONFIG parameters to ensure mathematical correctness
  * and prevent unprofitable trading configurations.
@@ -24530,111 +23062,6 @@ class RiskReportService {
     }
 }
 
-const require = createRequire(import.meta.url);
-/**
- * Default fallback prompt configuration.
- * Used when signal.prompt.cjs file is not found.
- */
-const DEFAULT_PROMPT = {
-    user: "",
-    system: [],
-};
-/**
- * Lazy-loads and caches signal prompt configuration.
- * Attempts to load from config/prompt/signal.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
- * Uses singleshot pattern to ensure configuration is loaded only once.
- * @returns Prompt configuration with system and user prompts
- */
-const GET_PROMPT_FN = singleshot(() => {
-    try {
-        const modulePath = require.resolve(path.join(process.cwd(), `./config/prompt/signal.prompt.cjs`));
-        console.log(`Using ${modulePath} implementation as signal.prompt.cjs`);
-        return require(modulePath);
-    }
-    catch (error) {
-        console.log(`Using empty fallback for signal.prompt.cjs`, error);
-        return DEFAULT_PROMPT;
-    }
-});
-/**
- * Service for managing signal prompts for AI/LLM integrations.
- *
- * Provides access to system and user prompts configured in signal.prompt.cjs.
- * Supports both static prompt arrays and dynamic prompt functions.
- *
- * Key responsibilities:
- * - Lazy-loads prompt configuration from config/prompt/signal.prompt.cjs
- * - Resolves system prompts (static arrays or async functions)
- * - Provides user prompt strings
- * - Falls back to empty prompts if configuration is missing
- *
- * Used for AI-powered signal analysis and strategy recommendations.
- */
-class SignalPromptService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        /**
-         * Retrieves system prompts for AI context.
-         *
-         * System prompts can be:
-         * - Static array of strings (returned directly)
-         * - Async/sync function returning string array (executed and awaited)
-         * - Undefined (returns empty array)
-         *
-         * @param symbol - Trading symbol (e.g., "BTCUSDT")
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @param frameName - Timeframe identifier
-         * @param backtest - Whether running in backtest mode
-         * @returns Promise resolving to array of system prompt strings
-         */
-        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-            this.loggerService.log("signalPromptService getSystemPrompt", {
-                symbol,
-                strategyName,
-                exchangeName,
-                frameName,
-                backtest,
-            });
-            const { system } = GET_PROMPT_FN();
-            if (Array.isArray(system)) {
-                return system;
-            }
-            if (typeof system === "function") {
-                return await system(symbol, strategyName, exchangeName, frameName, backtest);
-            }
-            return [];
-        };
-        /**
-         * Retrieves user prompt string for AI input.
-         *
-         * @param symbol - Trading symbol (e.g., "BTCUSDT")
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @param frameName - Timeframe identifier
-         * @param backtest - Whether running in backtest mode
-         * @returns Promise resolving to user prompt string
-         */
-        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-            this.loggerService.log("signalPromptService getUserPrompt", {
-                symbol,
-                strategyName,
-                exchangeName,
-                frameName,
-                backtest,
-            });
-            const { user } = GET_PROMPT_FN();
-            if (typeof user === "string") {
-                return user;
-            }
-            if (typeof user === "function") {
-                return await user(symbol, strategyName, exchangeName, frameName, backtest);
-            }
-            return "";
-        };
-    }
-}
-
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -24649,7 +23076,6 @@ class SignalPromptService {
     provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
     provide(TYPES.riskConnectionService, () => new RiskConnectionService());
     provide(TYPES.actionConnectionService, () => new ActionConnectionService());
-    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
     provide(TYPES.partialConnectionService, () => new PartialConnectionService());
     provide(TYPES.breakevenConnectionService, () => new BreakevenConnectionService());
 }
@@ -24661,7 +23087,6 @@ class SignalPromptService {
     provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
     provide(TYPES.riskSchemaService, () => new RiskSchemaService());
     provide(TYPES.actionSchemaService, () => new ActionSchemaService());
-    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
 }
 {
     provide(TYPES.exchangeCoreService, () => new ExchangeCoreService());
@@ -24672,7 +23097,6 @@ class SignalPromptService {
 {
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
     provide(TYPES.riskGlobalService, () => new RiskGlobalService());
-    provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
     provide(TYPES.partialGlobalService, () => new PartialGlobalService());
     provide(TYPES.breakevenGlobalService, () => new BreakevenGlobalService());
 }
@@ -24700,7 +23124,6 @@ class SignalPromptService {
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
     provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
     provide(TYPES.breakevenMarkdownService, () => new BreakevenMarkdownService());
-    provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
     provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
 }
 {
@@ -24722,16 +23145,9 @@ class SignalPromptService {
     provide(TYPES.sizingValidationService, () => new SizingValidationService());
     provide(TYPES.riskValidationService, () => new RiskValidationService());
     provide(TYPES.actionValidationService, () => new ActionValidationService());
-    provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
     provide(TYPES.configValidationService, () => new ConfigValidationService());
     provide(TYPES.columnValidationService, () => new ColumnValidationService());
 }
-{
-    provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
-}
-{
-    provide(TYPES.signalPromptService, () => new SignalPromptService());
-}
 
 const baseServices = {
     loggerService: inject(TYPES.loggerService),
@@ -24747,7 +23163,6 @@ const connectionServices = {
     sizingConnectionService: inject(TYPES.sizingConnectionService),
     riskConnectionService: inject(TYPES.riskConnectionService),
     actionConnectionService: inject(TYPES.actionConnectionService),
-    optimizerConnectionService: inject(TYPES.optimizerConnectionService),
     partialConnectionService: inject(TYPES.partialConnectionService),
     breakevenConnectionService: inject(TYPES.breakevenConnectionService),
 };
@@ -24759,7 +23174,6 @@ const schemaServices = {
     sizingSchemaService: inject(TYPES.sizingSchemaService),
     riskSchemaService: inject(TYPES.riskSchemaService),
     actionSchemaService: inject(TYPES.actionSchemaService),
-    optimizerSchemaService: inject(TYPES.optimizerSchemaService),
 };
 const coreServices = {
     exchangeCoreService: inject(TYPES.exchangeCoreService),
@@ -24770,7 +23184,6 @@ const coreServices = {
 const globalServices = {
     sizingGlobalService: inject(TYPES.sizingGlobalService),
     riskGlobalService: inject(TYPES.riskGlobalService),
-    optimizerGlobalService: inject(TYPES.optimizerGlobalService),
     partialGlobalService: inject(TYPES.partialGlobalService),
     breakevenGlobalService: inject(TYPES.breakevenGlobalService),
 };
@@ -24798,7 +23211,6 @@ const markdownServices = {
     heatMarkdownService: inject(TYPES.heatMarkdownService),
     partialMarkdownService: inject(TYPES.partialMarkdownService),
     breakevenMarkdownService: inject(TYPES.breakevenMarkdownService),
-    outlineMarkdownService: inject(TYPES.outlineMarkdownService),
     riskMarkdownService: inject(TYPES.riskMarkdownService),
 };
 const reportServices = {
@@ -24820,16 +23232,9 @@ const validationServices = {
     sizingValidationService: inject(TYPES.sizingValidationService),
     riskValidationService: inject(TYPES.riskValidationService),
     actionValidationService: inject(TYPES.actionValidationService),
-    optimizerValidationService: inject(TYPES.optimizerValidationService),
     configValidationService: inject(TYPES.configValidationService),
     columnValidationService: inject(TYPES.columnValidationService),
 };
-const templateServices = {
-    optimizerTemplateService: inject(TYPES.optimizerTemplateService),
-};
-const promptServices = {
-    signalPromptService: inject(TYPES.signalPromptService),
-};
 const backtest = {
     ...baseServices,
     ...contextServices,
@@ -24843,8 +23248,6 @@ const backtest = {
     ...markdownServices,
     ...reportServices,
     ...validationServices,
-    ...templateServices,
-    ...promptServices,
 };
 init();
 var bt = backtest;
@@ -24943,18 +23346,6 @@ const getSizingMap = async () => {
     }
     return sizingMap;
 };
-/**
- * Retrieves all registered optimizers as a map
- * @private
- * @returns Map of optimizer names
- */
-const getOptimizerMap = async () => {
-    const optimizerMap = {};
-    for (const { optimizerName } of await bt.optimizerValidationService.list()) {
-        Object.assign(optimizerMap, { [optimizerName]: optimizerName });
-    }
-    return optimizerMap;
-};
 /**
  * Retrieves all registered walkers as a map
  * @private
@@ -24981,7 +23372,7 @@ const getWalkerMap = async () => {
  * @throws {Error} If any entity name is not found in its registry
  */
 const validateInternal = async (args) => {
-    const { ExchangeName = await getExchangeMap(), FrameName = await getFrameMap(), StrategyName = await getStrategyMap(), RiskName = await getRiskMap(), ActionName = await getActionMap(), SizingName = await getSizingMap(), OptimizerName = await getOptimizerMap(), WalkerName = await getWalkerMap(), } = args;
+    const { ExchangeName = await getExchangeMap(), FrameName = await getFrameMap(), StrategyName = await getStrategyMap(), RiskName = await getRiskMap(), ActionName = await getActionMap(), SizingName = await getSizingMap(), WalkerName = await getWalkerMap(), } = args;
     for (const exchangeName of Object.values(ExchangeName)) {
         bt.exchangeValidationService.validate(exchangeName, METHOD_NAME);
     }
@@ -25000,9 +23391,6 @@ const validateInternal = async (args) => {
     for (const sizingName of Object.values(SizingName)) {
         bt.sizingValidationService.validate(sizingName, METHOD_NAME);
     }
-    for (const optimizerName of Object.values(OptimizerName)) {
-        bt.optimizerValidationService.validate(optimizerName, METHOD_NAME);
-    }
     for (const walkerName of Object.values(WalkerName)) {
         bt.walkerValidationService.validate(walkerName, METHOD_NAME);
     }
@@ -25011,7 +23399,7 @@ const validateInternal = async (args) => {
  * Validates the existence of all provided entity names across validation services.
  *
  * This function accepts enum objects for various entity types (exchanges, frames,
- * strategies, risks, sizings, optimizers, walkers) and validates that each entity
+ * strategies, risks, sizings, walkers) and validates that each entity
  * name exists in its respective registry. Validation results are memoized for performance.
  *
  * If no arguments are provided (or specific entity types are omitted), the function
@@ -25071,7 +23459,6 @@ const GET_FRAME_METHOD_NAME = "get.getFrameSchema";
 const GET_WALKER_METHOD_NAME = "get.getWalkerSchema";
 const GET_SIZING_METHOD_NAME = "get.getSizingSchema";
 const GET_RISK_METHOD_NAME = "get.getRiskSchema";
-const GET_OPTIMIZER_METHOD_NAME = "get.getOptimizerSchema";
 const GET_ACTION_METHOD_NAME = "get.getActionSchema";
 /**
  * Retrieves a registered strategy schema by name.
@@ -25203,29 +23590,6 @@ function getRiskSchema(riskName) {
     bt.riskValidationService.validate(riskName, GET_RISK_METHOD_NAME);
     return bt.riskSchemaService.get(riskName);
 }
-/**
- * Retrieves a registered optimizer schema by name.
- *
- * @param optimizerName - Unique optimizer identifier
- * @returns The optimizer schema configuration object
- * @throws Error if optimizer is not registered
- *
- * @example
- * ```typescript
- * const optimizer = getOptimizer("llm-strategy-generator");
- * console.log(optimizer.rangeTrain); // Array of training ranges
- * console.log(optimizer.rangeTest); // Testing range
- * console.log(optimizer.source); // Array of data sources
- * console.log(optimizer.getPrompt); // async function
- * ```
- */
-function getOptimizerSchema(optimizerName) {
-    bt.loggerService.log(GET_OPTIMIZER_METHOD_NAME, {
-        optimizerName,
-    });
-    bt.optimizerValidationService.validate(optimizerName, GET_OPTIMIZER_METHOD_NAME);
-    return bt.optimizerSchemaService.get(optimizerName);
-}
 /**
  * Retrieves a registered action schema by name.
  *
@@ -25258,6 +23622,7 @@ const GET_SYMBOL_METHOD_NAME = "exchange.getSymbol";
 const GET_CONTEXT_METHOD_NAME = "exchange.getContext";
 const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
 const GET_ORDER_BOOK_METHOD_NAME = "exchange.getOrderBook";
+const GET_RAW_CANDLES_METHOD_NAME = "exchange.getRawCandles";
 /**
  * Checks if trade context is active (execution and method contexts).
  *
@@ -25498,22 +23863,69 @@ async function getContext() {
  * console.log(orderBook.bids); // [{ price: "50000.00", quantity: "0.5" }, ...]
  * console.log(orderBook.asks); // [{ price: "50001.00", quantity: "0.3" }, ...]
  *
- * // Fetch deeper order book
- * const deepBook = await getOrderBook("BTCUSDT", 100);
+ * // Fetch deeper order book
+ * const deepBook = await getOrderBook("BTCUSDT", 100);
+ * ```
+ */
+async function getOrderBook(symbol, depth) {
+    bt.loggerService.info(GET_ORDER_BOOK_METHOD_NAME, {
+        symbol,
+        depth,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getOrderBook requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getOrderBook requires a method context");
+    }
+    return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
+}
+/**
+ * Fetches raw candles with flexible date/limit parameters.
+ *
+ * All modes respect execution context and prevent look-ahead bias.
+ *
+ * Parameter combinations:
+ * 1. sDate + eDate + limit: fetches with explicit parameters, validates eDate <= when
+ * 2. sDate + eDate: calculates limit from date range, validates eDate <= when
+ * 3. eDate + limit: calculates sDate backward, validates eDate <= when
+ * 4. sDate + limit: fetches forward, validates calculated endTimestamp <= when
+ * 5. Only limit: uses execution.context.when as reference (backward)
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
+ * @param limit - Optional number of candles to fetch
+ * @param sDate - Optional start date in milliseconds
+ * @param eDate - Optional end date in milliseconds
+ * @returns Promise resolving to array of candle data
+ *
+ * @example
+ * ```typescript
+ * // Fetch 100 candles backward from current context time
+ * const candles = await getRawCandles("BTCUSDT", "1m", 100);
+ *
+ * // Fetch candles for specific date range
+ * const rangeCandles = await getRawCandles("BTCUSDT", "1h", undefined, startMs, endMs);
+ *
+ * // Fetch with all parameters specified
+ * const exactCandles = await getRawCandles("BTCUSDT", "1m", 100, startMs, endMs);
  * ```
  */
-async function getOrderBook(symbol, depth) {
-    bt.loggerService.info(GET_ORDER_BOOK_METHOD_NAME, {
+async function getRawCandles(symbol, interval, limit, sDate, eDate) {
+    bt.loggerService.info(GET_RAW_CANDLES_METHOD_NAME, {
         symbol,
-        depth,
+        interval,
+        limit,
+        sDate,
+        eDate,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("getOrderBook requires an execution context");
+        throw new Error("getRawCandles requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("getOrderBook requires a method context");
+        throw new Error("getRawCandles requires a method context");
     }
-    return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
+    return await bt.exchangeConnectionService.getRawCandles(symbol, interval, limit, sDate, eDate);
 }
 
 const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
@@ -26038,7 +24450,6 @@ const ADD_FRAME_METHOD_NAME = "add.addFrameSchema";
 const ADD_WALKER_METHOD_NAME = "add.addWalkerSchema";
 const ADD_SIZING_METHOD_NAME = "add.addSizingSchema";
 const ADD_RISK_METHOD_NAME = "add.addRiskSchema";
-const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizerSchema";
 const ADD_ACTION_METHOD_NAME = "add.addActionSchema";
 /**
  * Registers a trading strategy in the framework.
@@ -26331,100 +24742,6 @@ function addRiskSchema(riskSchema) {
     bt.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
     bt.riskSchemaService.register(riskSchema.riskName, riskSchema);
 }
-/**
- * Registers an optimizer configuration in the framework.
- *
- * The optimizer generates trading strategies by:
- * - Collecting data from multiple sources across training periods
- * - Building LLM conversation history with fetched data
- * - Generating strategy prompts using getPrompt()
- * - Creating executable backtest code with templates
- *
- * The optimizer produces a complete .mjs file containing:
- * - Exchange, Frame, Strategy, and Walker configurations
- * - Multi-timeframe analysis logic
- * - LLM integration for signal generation
- * - Event listeners for progress tracking
- *
- * @param optimizerSchema - Optimizer configuration object
- * @param optimizerSchema.optimizerName - Unique optimizer identifier
- * @param optimizerSchema.rangeTrain - Array of training time ranges (each generates a strategy variant)
- * @param optimizerSchema.rangeTest - Testing time range for strategy validation
- * @param optimizerSchema.source - Array of data sources (functions or source objects with custom formatters)
- * @param optimizerSchema.getPrompt - Function to generate strategy prompt from conversation history
- * @param optimizerSchema.template - Optional custom template overrides (top banner, helpers, strategy logic, etc.)
- * @param optimizerSchema.callbacks - Optional lifecycle callbacks (onData, onCode, onDump, onSourceData)
- *
- * @example
- * ```typescript
- * // Basic optimizer with single data source
- * addOptimizer({
- *   optimizerName: "llm-strategy-generator",
- *   rangeTrain: [
- *     {
- *       note: "Bull market period",
- *       startDate: new Date("2024-01-01"),
- *       endDate: new Date("2024-01-31"),
- *     },
- *     {
- *       note: "Bear market period",
- *       startDate: new Date("2024-02-01"),
- *       endDate: new Date("2024-02-28"),
- *     },
- *   ],
- *   rangeTest: {
- *     note: "Validation period",
- *     startDate: new Date("2024-03-01"),
- *     endDate: new Date("2024-03-31"),
- *   },
- *   source: [
- *     {
- *       name: "historical-backtests",
- *       fetch: async ({ symbol, startDate, endDate, limit, offset }) => {
- *         // Fetch historical backtest results from database
- *         return await db.backtests.find({
- *           symbol,
- *           date: { $gte: startDate, $lte: endDate },
- *         })
- *         .skip(offset)
- *         .limit(limit);
- *       },
- *       user: async (symbol, data, name) => {
- *         return `Analyze these ${data.length} backtest results for ${symbol}:\n${JSON.stringify(data)}`;
- *       },
- *       assistant: async (symbol, data, name) => {
- *         return "Historical data analyzed successfully";
- *       },
- *     },
- *   ],
- *   getPrompt: async (symbol, messages) => {
- *     // Generate strategy prompt from conversation
- *     return `"Analyze ${symbol} using RSI and MACD. Enter LONG when RSI < 30 and MACD crosses above signal."`;
- *   },
- *   callbacks: {
- *     onData: (symbol, strategyData) => {
- *       console.log(`Generated ${strategyData.length} strategies for ${symbol}`);
- *     },
- *     onCode: (symbol, code) => {
- *       console.log(`Generated ${code.length} characters of code for ${symbol}`);
- *     },
- *     onDump: (symbol, filepath) => {
- *       console.log(`Saved strategy to ${filepath}`);
- *     },
- *     onSourceData: (symbol, sourceName, data, startDate, endDate) => {
- *       console.log(`Fetched ${data.length} rows from ${sourceName} for ${symbol}`);
- *     },
- *   },
- * });
- * ```
- */
-function addOptimizerSchema(optimizerSchema) {
-    bt.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
-        optimizerSchema,
-    });
-    bt.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
-    bt.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
-}
 /**
  * Registers an action handler in the framework.
  *
@@ -26507,7 +24824,6 @@ const METHOD_NAME_OVERRIDE_FRAME = "function.override.overrideFrameSchema";
 const METHOD_NAME_OVERRIDE_WALKER = "function.override.overrideWalkerSchema";
 const METHOD_NAME_OVERRIDE_SIZING = "function.override.overrideSizingSchema";
 const METHOD_NAME_OVERRIDE_RISK = "function.override.overrideRiskSchema";
-const METHOD_NAME_OVERRIDE_OPTIMIZER = "function.override.overrideOptimizerSchema";
 const METHOD_NAME_OVERRIDE_ACTION = "function.override.overrideActionSchema";
 /**
  * Overrides an existing trading strategy in the framework.
@@ -26680,40 +24996,6 @@ async function overrideRiskSchema(riskSchema) {
     await bt.riskValidationService.validate(riskSchema.riskName, METHOD_NAME_OVERRIDE_RISK);
     return bt.riskSchemaService.override(riskSchema.riskName, riskSchema);
 }
-/**
- * Overrides an existing optimizer configuration in the framework.
- *
- * This function partially updates a previously registered optimizer with new configuration.
- * Only the provided fields will be updated, other fields remain unchanged.
- *
- * @param optimizerSchema - Partial optimizer configuration object
- * @param optimizerSchema.optimizerName - Unique optimizer identifier (must exist)
- * @param optimizerSchema.rangeTrain - Optional: Array of training time ranges
- * @param optimizerSchema.rangeTest - Optional: Testing time range
- * @param optimizerSchema.source - Optional: Array of data sources
- * @param optimizerSchema.getPrompt - Optional: Function to generate strategy prompt
- * @param optimizerSchema.template - Optional: Custom template overrides
- * @param optimizerSchema.callbacks - Optional: Lifecycle callbacks
- *
- * @example
- * ```typescript
- * overrideOptimizer({
- *   optimizerName: "llm-strategy-generator",
- *   rangeTest: {
- *     note: "Updated validation period",
- *     startDate: new Date("2024-04-01"),
- *     endDate: new Date("2024-04-30"),
- *   },
- * });
- * ```
- */
-async function overrideOptimizerSchema(optimizerSchema) {
-    bt.loggerService.log(METHOD_NAME_OVERRIDE_OPTIMIZER, {
-        optimizerSchema,
-    });
-    await bt.optimizerValidationService.validate(optimizerSchema.optimizerName, METHOD_NAME_OVERRIDE_OPTIMIZER);
-    return bt.optimizerSchemaService.override(optimizerSchema.optimizerName, optimizerSchema);
-}
 /**
  * Overrides an existing action handler configuration in the framework.
  *
@@ -26788,7 +25070,6 @@ const LIST_FRAMES_METHOD_NAME = "list.listFrameSchema";
 const LIST_WALKERS_METHOD_NAME = "list.listWalkerSchema";
 const LIST_SIZINGS_METHOD_NAME = "list.listSizingSchema";
 const LIST_RISKS_METHOD_NAME = "list.listRiskSchema";
-const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizerSchema";
 /**
  * Returns a list of all registered exchange schemas.
  *
@@ -26986,46 +25267,6 @@ async function listRiskSchema() {
     bt.loggerService.log(LIST_RISKS_METHOD_NAME);
     return await bt.riskValidationService.list();
 }
-/**
- * Returns a list of all registered optimizer schemas.
- *
- * Retrieves all optimizers that have been registered via addOptimizer().
- * Useful for debugging, documentation, or building dynamic UIs.
- *
- * @returns Array of optimizer schemas with their configurations
- *
- * @example
- * ```typescript
- * import { listOptimizers, addOptimizer } from "backtest-kit";
- *
- * addOptimizer({
- *   optimizerName: "llm-strategy-generator",
- *   note: "Generates trading strategies using LLM",
- *   rangeTrain: [
- *     {
- *       note: "Training period 1",
- *       startDate: new Date("2024-01-01"),
- *       endDate: new Date("2024-01-31"),
- *     },
- *   ],
- *   rangeTest: {
- *     note: "Testing period",
- *     startDate: new Date("2024-02-01"),
- *     endDate: new Date("2024-02-28"),
- *   },
- *   source: [],
- *   getPrompt: async (symbol, messages) => "Generate strategy",
- * });
- *
- * const optimizers = listOptimizers();
- * console.log(optimizers);
- * // [{ optimizerName: "llm-strategy-generator", note: "Generates...", ... }]
- * ```
- */
-async function listOptimizerSchema() {
-    bt.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
-    return await bt.optimizerValidationService.list();
-}
 
 const LISTEN_SIGNAL_METHOD_NAME = "event.listenSignal";
 const LISTEN_SIGNAL_ONCE_METHOD_NAME = "event.listenSignalOnce";
@@ -27043,7 +25284,6 @@ const LISTEN_DONE_WALKER_METHOD_NAME = "event.listenDoneWalker";
 const LISTEN_DONE_WALKER_ONCE_METHOD_NAME = "event.listenDoneWalkerOnce";
 const LISTEN_PROGRESS_METHOD_NAME = "event.listenBacktestProgress";
 const LISTEN_PROGRESS_WALKER_METHOD_NAME = "event.listenWalkerProgress";
-const LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME = "event.listenOptimizerProgress";
 const LISTEN_PERFORMANCE_METHOD_NAME = "event.listenPerformance";
 const LISTEN_WALKER_METHOD_NAME = "event.listenWalker";
 const LISTEN_WALKER_ONCE_METHOD_NAME = "event.listenWalkerOnce";
@@ -27531,34 +25771,6 @@ function listenWalkerProgress(fn) {
     bt.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
     return progressWalkerEmitter.subscribe(queued(async (event) => fn(event)));
 }
-/**
- * Subscribes to optimizer progress events with queued async processing.
- *
- * Emits during optimizer execution to track data source processing progress.
- * Events are processed sequentially in order received, even if callback is async.
- * Uses queued wrapper to prevent concurrent execution of the callback.
- *
- * @param fn - Callback function to handle optimizer progress events
- * @returns Unsubscribe function to stop listening to events
- *
- * @example
- * ```typescript
- * import { listenOptimizerProgress } from "backtest-kit";
- *
- * const unsubscribe = listenOptimizerProgress((event) => {
- *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
- *   console.log(`${event.processedSources} / ${event.totalSources} sources`);
- *   console.log(`Optimizer: ${event.optimizerName}, Symbol: ${event.symbol}`);
- * });
- *
- * // Later: stop listening
- * unsubscribe();
- * ```
- */
-function listenOptimizerProgress(fn) {
-    bt.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
-    return progressOptimizerEmitter.subscribe(queued(async (event) => fn(event)));
-}
 /**
  * Subscribes to performance metric events with queued async processing.
  *
@@ -28119,138 +26331,6 @@ function listenActivePingOnce(filterFn, fn) {
     return activePingSubject.filter(filterFn).once(fn);
 }
 
-const METHOD_NAME_SIGNAL = "history.commitSignalPromptHistory";
-/**
- * Commits signal prompt history to the message array.
- *
- * Extracts trading context from ExecutionContext and MethodContext,
- * then adds signal-specific system prompts at the beginning and user prompt
- * at the end of the history array if they are not empty.
- *
- * Context extraction:
- * - symbol: Provided as parameter for debugging convenience
- * - backtest mode: From ExecutionContext
- * - strategyName, exchangeName, frameName: From MethodContext
- *
- * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
- * @param history - Message array to append prompts to
- * @returns Promise that resolves when prompts are added
- * @throws Error if ExecutionContext or MethodContext is not active
- *
- * @example
- * ```typescript
- * const messages: MessageModel[] = [];
- * await commitSignalPromptHistory("BTCUSDT", messages);
- * // messages now contains system prompts at start and user prompt at end
- * ```
- */
-async function commitSignalPromptHistory(symbol, history) {
-    bt.loggerService.log(METHOD_NAME_SIGNAL, {
-        symbol,
-    });
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("commitSignalPromptHistory requires an execution context");
-    }
-    if (!MethodContextService.hasContext()) {
-        throw new Error("commitSignalPromptHistory requires a method context");
-    }
-    const { backtest: isBacktest } = bt.executionContextService.context;
-    const { strategyName, exchangeName, frameName } = bt.methodContextService.context;
-    const systemPrompts = await bt.signalPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
-    const userPrompt = await bt.signalPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
-    if (systemPrompts.length > 0) {
-        for (const content of systemPrompts) {
-            history.unshift({
-                role: "system",
-                content,
-            });
-        }
-    }
-    if (userPrompt && userPrompt.trim() !== "") {
-        history.push({
-            role: "user",
-            content: userPrompt,
-        });
-    }
-}
-
-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 dumpSignalData(signalId, history, signal, outputDir = "./dump/strategy") {
-    bt.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
-        signalId,
-        history,
-        signal,
-        outputDir,
-    });
-    return await bt.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
-}
-
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
 const BACKTEST_METHOD_NAME_STOP = "BacktestUtils.stop";
@@ -31410,104 +29490,6 @@ PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, cont
 };
 const PositionSize = PositionSizeUtils;
 
-const OPTIMIZER_METHOD_NAME_GET_DATA = "OptimizerUtils.getData";
-const OPTIMIZER_METHOD_NAME_GET_CODE = "OptimizerUtils.getCode";
-const OPTIMIZER_METHOD_NAME_DUMP = "OptimizerUtils.dump";
-/**
- * Public API utilities for optimizer operations.
- * Provides high-level methods for strategy generation and code export.
- *
- * Usage:
- * ```typescript
- * import { Optimizer } from "backtest-kit";
- *
- * // Get strategy data
- * const strategies = await Optimizer.getData("BTCUSDT", {
- *   optimizerName: "my-optimizer"
- * });
- *
- * // Generate code
- * const code = await Optimizer.getCode("BTCUSDT", {
- *   optimizerName: "my-optimizer"
- * });
- *
- * // Save to file
- * await Optimizer.dump("BTCUSDT", {
- *   optimizerName: "my-optimizer"
- * }, "./output");
- * ```
- */
-class OptimizerUtils {
-    constructor() {
-        /**
-         * Fetches data from all sources and generates strategy metadata.
-         * Processes each training range and builds LLM conversation history.
-         *
-         * @param symbol - Trading pair symbol
-         * @param context - Context with optimizerName
-         * @returns Array of generated strategies with conversation context
-         * @throws Error if optimizer not found
-         */
-        this.getData = async (symbol, context) => {
-            bt.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
-                symbol,
-                context,
-            });
-            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_DATA);
-            return await bt.optimizerGlobalService.getData(symbol, context.optimizerName);
-        };
-        /**
-         * Generates complete executable strategy code.
-         * Includes imports, helpers, strategies, walker, and launcher.
-         *
-         * @param symbol - Trading pair symbol
-         * @param context - Context with optimizerName
-         * @returns Generated TypeScript/JavaScript code as string
-         * @throws Error if optimizer not found
-         */
-        this.getCode = async (symbol, context) => {
-            bt.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
-                symbol,
-                context,
-            });
-            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_CODE);
-            return await bt.optimizerGlobalService.getCode(symbol, context.optimizerName);
-        };
-        /**
-         * Generates and saves strategy code to file.
-         * Creates directory if needed, writes .mjs file.
-         *
-         * Format: `{optimizerName}_{symbol}.mjs`
-         *
-         * @param symbol - Trading pair symbol
-         * @param context - Context with optimizerName
-         * @param path - Output directory path (default: "./")
-         * @throws Error if optimizer not found or file write fails
-         */
-        this.dump = async (symbol, context, path) => {
-            bt.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
-                symbol,
-                context,
-                path,
-            });
-            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_DUMP);
-            await bt.optimizerGlobalService.dump(symbol, context.optimizerName, path);
-        };
-    }
-}
-/**
- * Singleton instance of OptimizerUtils.
- * Public API for optimizer operations.
- *
- * @example
- * ```typescript
- * import { Optimizer } from "backtest-kit";
- *
- * await Optimizer.dump("BTCUSDT", { optimizerName: "my-optimizer" });
- * ```
- */
-const Optimizer = new OptimizerUtils();
-
 const PARTIAL_METHOD_NAME_GET_DATA = "PartialUtils.getData";
 const PARTIAL_METHOD_NAME_GET_REPORT = "PartialUtils.getReport";
 const PARTIAL_METHOD_NAME_DUMP = "PartialUtils.dump";
@@ -31786,6 +29768,8 @@ const EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE = "ExchangeUtils.getAveragePrice";
 const EXCHANGE_METHOD_NAME_FORMAT_QUANTITY = "ExchangeUtils.formatQuantity";
 const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
 const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
+const EXCHANGE_METHOD_NAME_GET_RAW_CANDLES = "ExchangeUtils.getRawCandles";
+const MS_PER_MINUTE = 60000;
 /**
  * Gets backtest mode flag from execution context if available.
  * Returns false if no execution context exists (live mode).
@@ -32139,6 +30123,151 @@ class ExchangeInstance {
             const isBacktest = await GET_BACKTEST_FN();
             return await this._methods.getOrderBook(symbol, depth, from, to, isBacktest);
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters.
+         *
+         * Uses Date.now() instead of execution context when for look-ahead bias protection.
+         *
+         * Parameter combinations:
+         * 1. sDate + eDate + limit: fetches with explicit parameters, validates eDate <= now
+         * 2. sDate + eDate: calculates limit from date range, validates eDate <= now
+         * 3. eDate + limit: calculates sDate backward, validates eDate <= now
+         * 4. sDate + limit: fetches forward, validates calculated endTimestamp <= now
+         * 5. Only limit: uses Date.now() as reference (backward)
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candle data
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         *
+         * // Fetch 100 candles backward from now
+         * const candles = await instance.getRawCandles("BTCUSDT", "1m", 100);
+         *
+         * // Fetch candles for specific date range
+         * const rangeCandles = await instance.getRawCandles("BTCUSDT", "1h", undefined, startMs, endMs);
+         * ```
+         */
+        this.getRawCandles = async (symbol, interval, limit, sDate, eDate) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_RAW_CANDLES, {
+                exchangeName: this.exchangeName,
+                symbol,
+                interval,
+                limit,
+                sDate,
+                eDate,
+            });
+            const step = INTERVAL_MINUTES$1[interval];
+            if (!step) {
+                throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
+            }
+            const nowTimestamp = Date.now();
+            let sinceTimestamp;
+            let untilTimestamp;
+            let calculatedLimit;
+            // Case 1: all three parameters provided
+            if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
+                if (sDate >= eDate) {
+                    throw new Error(`ExchangeInstance getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+                }
+                if (eDate > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                }
+                sinceTimestamp = sDate;
+                untilTimestamp = eDate;
+                calculatedLimit = limit;
+            }
+            // Case 2: sDate + eDate (no limit) - calculate limit from date range
+            else if (sDate !== undefined && eDate !== undefined && limit === undefined) {
+                if (sDate >= eDate) {
+                    throw new Error(`ExchangeInstance getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+                }
+                if (eDate > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                }
+                sinceTimestamp = sDate;
+                untilTimestamp = eDate;
+                calculatedLimit = Math.ceil((eDate - sDate) / (step * MS_PER_MINUTE));
+                if (calculatedLimit <= 0) {
+                    throw new Error(`ExchangeInstance getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
+                }
+            }
+            // Case 3: eDate + limit (no sDate) - calculate sDate backward from eDate
+            else if (sDate === undefined && eDate !== undefined && limit !== undefined) {
+                if (eDate > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                }
+                untilTimestamp = eDate;
+                sinceTimestamp = eDate - limit * step * MS_PER_MINUTE;
+                calculatedLimit = limit;
+            }
+            // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
+            else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
+                sinceTimestamp = sDate;
+                untilTimestamp = sDate + limit * step * MS_PER_MINUTE;
+                if (untilTimestamp > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${untilTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                }
+                calculatedLimit = limit;
+            }
+            // Case 5: Only limit - use Date.now() as reference (backward)
+            else if (sDate === undefined && eDate === undefined && limit !== undefined) {
+                untilTimestamp = nowTimestamp;
+                sinceTimestamp = nowTimestamp - limit * step * MS_PER_MINUTE;
+                calculatedLimit = limit;
+            }
+            // Invalid: no parameters or only sDate or only eDate
+            else {
+                throw new Error(`ExchangeInstance getRawCandles: invalid parameter combination. ` +
+                    `Provide one of: (sDate+eDate+limit), (sDate+eDate), (eDate+limit), (sDate+limit), or (limit only). ` +
+                    `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
+            }
+            // Try to read from cache first
+            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit: calculatedLimit }, sinceTimestamp, untilTimestamp, this.exchangeName);
+            if (cachedCandles !== null) {
+                return cachedCandles;
+            }
+            // Fetch candles
+            const since = new Date(sinceTimestamp);
+            let allData = [];
+            const isBacktest = await GET_BACKTEST_FN();
+            const getCandles = this._methods.getCandles;
+            if (calculatedLimit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+                let remaining = calculatedLimit;
+                let currentSince = new Date(since.getTime());
+                while (remaining > 0) {
+                    const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                    const chunkData = await getCandles(symbol, interval, currentSince, chunkLimit, isBacktest);
+                    allData.push(...chunkData);
+                    remaining -= chunkLimit;
+                    if (remaining > 0) {
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE);
+                    }
+                }
+            }
+            else {
+                allData = await getCandles(symbol, interval, since, calculatedLimit, isBacktest);
+            }
+            // Filter candles to strictly match the requested range
+            const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp &&
+                candle.timestamp < untilTimestamp);
+            // Apply distinct by timestamp to remove duplicates
+            const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+            if (filteredData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            if (uniqueData.length < calculatedLimit) {
+                bt.loggerService.warn(`ExchangeInstance getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`);
+            }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit: calculatedLimit }, this.exchangeName);
+            return uniqueData;
+        };
         const schema = bt.exchangeSchemaService.get(this.exchangeName);
         this._methods = CREATE_EXCHANGE_INSTANCE_FN(schema);
     }
@@ -32243,6 +30372,24 @@ class ExchangeUtils {
             const instance = this._getInstance(context.exchangeName);
             return await instance.getOrderBook(symbol, depth);
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters.
+         *
+         * Uses Date.now() instead of execution context when for look-ahead bias protection.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param context - Execution context with exchange name
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candle data
+         */
+        this.getRawCandles = async (symbol, interval, context, limit, sDate, eDate) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_RAW_CANDLES);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.getRawCandles(symbol, interval, limit, sDate, eDate);
+        };
     }
 }
 /**
@@ -33374,4 +31521,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };