backtest-kit 2.1.2 → 2.2.1

package/build/index.cjs

@@ -8,10 +8,8 @@ var path = require('path');
 var crypto = require('crypto');
 var os = require('os');
 var fs$1 = require('fs');
-var module$1 = require('module');
 var util = require('util');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
@@ -73,7 +71,6 @@ const connectionServices$1 = {
     sizingConnectionService: Symbol('sizingConnectionService'),
     riskConnectionService: Symbol('riskConnectionService'),
     actionConnectionService: Symbol('actionConnectionService'),
-    optimizerConnectionService: Symbol('optimizerConnectionService'),
     partialConnectionService: Symbol('partialConnectionService'),
     breakevenConnectionService: Symbol('breakevenConnectionService'),
 };
@@ -85,7 +82,6 @@ const schemaServices$1 = {
     sizingSchemaService: Symbol('sizingSchemaService'),
     riskSchemaService: Symbol('riskSchemaService'),
     actionSchemaService: Symbol('actionSchemaService'),
-    optimizerSchemaService: Symbol('optimizerSchemaService'),
 };
 const coreServices$1 = {
     exchangeCoreService: Symbol('exchangeCoreService'),
@@ -96,7 +92,6 @@ const coreServices$1 = {
 const globalServices$1 = {
     sizingGlobalService: Symbol('sizingGlobalService'),
     riskGlobalService: Symbol('riskGlobalService'),
-    optimizerGlobalService: Symbol('optimizerGlobalService'),
     partialGlobalService: Symbol('partialGlobalService'),
     breakevenGlobalService: Symbol('breakevenGlobalService'),
 };
@@ -146,16 +141,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,
@@ -169,8 +157,6 @@ const TYPES = {
     ...markdownServices$1,
     ...reportServices$1,
     ...validationServices$1,
-    ...templateServices$1,
-    ...promptServices$1,
 };
 
 /**
@@ -494,11 +480,6 @@ const progressBacktestEmitter = new functoolsKit.Subject();
  * Emits progress updates during walker execution.
  */
 const progressWalkerEmitter = new functoolsKit.Subject();
-/**
- * Progress emitter for optimizer execution progress.
- * Emits progress updates during optimizer execution.
- */
-const progressOptimizerEmitter = new functoolsKit.Subject();
 /**
  * Performance emitter for execution metrics.
  * Emits performance metrics for profiling and bottleneck detection.
@@ -573,7 +554,6 @@ var emitters = /*#__PURE__*/Object.freeze({
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
     progressBacktestEmitter: progressBacktestEmitter,
-    progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
     riskSubject: riskSubject,
     schedulePingSubject: schedulePingSubject,
@@ -1667,6 +1647,7 @@ class PersistCandleUtils {
  */
 const PersistCandleAdapter = new PersistCandleUtils();
 
+const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
@@ -1812,7 +1793,7 @@ const WRITE_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(functoolsKit.queued(async
 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) {
@@ -1918,7 +1899,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) {
@@ -1931,7 +1912,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);
                 }
             }
         }
@@ -1978,7 +1959,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 [];
@@ -1995,7 +1976,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);
                 }
             }
         }
@@ -2090,22 +2071,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
@@ -2124,73 +2102,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);
@@ -2198,16 +2178,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) {
@@ -2215,12 +2195,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;
     }
     /**
@@ -2242,7 +2222,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);
     }
 }
@@ -2433,6 +2413,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);
+        };
     }
 }
 
@@ -9976,6 +9978,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,
+            });
+        };
     }
 }
 
@@ -18365,1469 +18401,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 functoolsKit.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 = functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
-            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
-            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
-            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
-            message: functoolsKit.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 = functoolsKit.iterateDocuments({
-        limit: ITERATION_LIMIT,
-        async createRequest({ limit, offset }) {
-            return await fetch({
-                symbol: filterData.symbol,
-                startDate: filterData.startDate,
-                endDate: filterData.endDate,
-                limit,
-                offset,
-            });
-        },
-    });
-    const distinct = functoolsKit.distinctDocuments(iterator, (data) => data.id);
-    return await functoolsKit.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$1, self) => {
-    const report = await self.getCode(symbol);
-    try {
-        const dir = path.join(process.cwd(), path$1);
-        await fs.mkdir(dir, { recursive: true });
-        const filename = `${self.params.optimizerName}_${symbol}.mjs`;
-        const filepath = path.join(dir, filename);
-        await fs.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 = functoolsKit.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.
@@ -22010,162 +20697,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.
@@ -24551,111 +23082,6 @@ class RiskReportService {
     }
 }
 
-const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-/**
- * 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 = functoolsKit.singleshot(() => {
-    try {
-        const modulePath = require$1.resolve(path.join(process.cwd(), `./config/prompt/signal.prompt.cjs`));
-        console.log(`Using ${modulePath} implementation as signal.prompt.cjs`);
-        return require$1(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());
 }
@@ -24670,7 +23096,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());
 }
@@ -24682,7 +23107,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());
@@ -24693,7 +23117,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());
 }
@@ -24721,7 +23144,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());
 }
 {
@@ -24743,16 +23165,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),
@@ -24768,7 +23183,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),
 };
@@ -24780,7 +23194,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),
@@ -24791,7 +23204,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),
 };
@@ -24819,7 +23231,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 = {
@@ -24841,16 +23252,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,
@@ -24864,8 +23268,6 @@ const backtest = {
     ...markdownServices,
     ...reportServices,
     ...validationServices,
-    ...templateServices,
-    ...promptServices,
 };
 init();
 var bt = backtest;
@@ -24964,18 +23366,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
@@ -25002,7 +23392,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);
     }
@@ -25021,9 +23411,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);
     }
@@ -25032,7 +23419,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
@@ -25092,7 +23479,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.
@@ -25224,29 +23610,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.
  *
@@ -25279,6 +23642,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).
  *
@@ -25519,22 +23883,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";
@@ -26059,7 +24470,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.
@@ -26352,100 +24762,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.
  *
@@ -26528,7 +24844,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.
@@ -26701,40 +25016,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.
  *
@@ -26809,7 +25090,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.
  *
@@ -27007,46 +25287,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";
@@ -27064,7 +25304,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";
@@ -27552,34 +25791,6 @@ function listenWalkerProgress(fn) {
     bt.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
     return progressWalkerEmitter.subscribe(functoolsKit.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(functoolsKit.queued(async (event) => fn(event)));
-}
 /**
  * Subscribes to performance metric events with queued async processing.
  *
@@ -28140,138 +26351,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";
@@ -31431,104 +29510,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";
@@ -31807,6 +29788,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).
@@ -32160,6 +30143,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);
     }
@@ -32264,6 +30392,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);
+        };
     }
 }
 /**
@@ -33409,7 +31555,6 @@ exports.MarkdownFileBase = MarkdownFileBase;
 exports.MarkdownFolderBase = MarkdownFolderBase;
 exports.MethodContextService = MethodContextService;
 exports.Notification = Notification;
-exports.Optimizer = Optimizer;
 exports.Partial = Partial;
 exports.Performance = Performance;
 exports.PersistBase = PersistBase;
@@ -33428,7 +31573,6 @@ exports.Walker = Walker;
 exports.addActionSchema = addActionSchema;
 exports.addExchangeSchema = addExchangeSchema;
 exports.addFrameSchema = addFrameSchema;
-exports.addOptimizerSchema = addOptimizerSchema;
 exports.addRiskSchema = addRiskSchema;
 exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
@@ -33438,10 +31582,8 @@ exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;
 exports.commitPartialLoss = commitPartialLoss;
 exports.commitPartialProfit = commitPartialProfit;
-exports.commitSignalPromptHistory = commitSignalPromptHistory;
 exports.commitTrailingStop = commitTrailingStop;
 exports.commitTrailingTake = commitTrailingTake;
-exports.dumpSignalData = dumpSignalData;
 exports.emitters = emitters;
 exports.formatPrice = formatPrice;
 exports.formatQuantity = formatQuantity;
@@ -33459,8 +31601,8 @@ exports.getDefaultConfig = getDefaultConfig;
 exports.getExchangeSchema = getExchangeSchema;
 exports.getFrameSchema = getFrameSchema;
 exports.getMode = getMode;
-exports.getOptimizerSchema = getOptimizerSchema;
 exports.getOrderBook = getOrderBook;
+exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;
 exports.getSizingSchema = getSizingSchema;
 exports.getStrategySchema = getStrategySchema;
@@ -33470,7 +31612,6 @@ exports.hasTradeContext = hasTradeContext;
 exports.lib = backtest;
 exports.listExchangeSchema = listExchangeSchema;
 exports.listFrameSchema = listFrameSchema;
-exports.listOptimizerSchema = listOptimizerSchema;
 exports.listRiskSchema = listRiskSchema;
 exports.listSizingSchema = listSizingSchema;
 exports.listStrategySchema = listStrategySchema;
@@ -33488,7 +31629,6 @@ exports.listenDoneWalker = listenDoneWalker;
 exports.listenDoneWalkerOnce = listenDoneWalkerOnce;
 exports.listenError = listenError;
 exports.listenExit = listenExit;
-exports.listenOptimizerProgress = listenOptimizerProgress;
 exports.listenPartialLossAvailable = listenPartialLossAvailable;
 exports.listenPartialLossAvailableOnce = listenPartialLossAvailableOnce;
 exports.listenPartialProfitAvailable = listenPartialProfitAvailable;
@@ -33512,7 +31652,6 @@ exports.listenWalkerProgress = listenWalkerProgress;
 exports.overrideActionSchema = overrideActionSchema;
 exports.overrideExchangeSchema = overrideExchangeSchema;
 exports.overrideFrameSchema = overrideFrameSchema;
-exports.overrideOptimizerSchema = overrideOptimizerSchema;
 exports.overrideRiskSchema = overrideRiskSchema;
 exports.overrideSizingSchema = overrideSizingSchema;
 exports.overrideStrategySchema = overrideStrategySchema;