backtest-kit 1.3.1 → 1.4.0

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, resolveDocuments, str, queued } from 'functools-kit';
+import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, resolveDocuments, str, iterateDocuments, distinctDocuments, queued } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -116,6 +116,8 @@ const connectionServices$1 = {
     frameConnectionService: Symbol('frameConnectionService'),
     sizingConnectionService: Symbol('sizingConnectionService'),
     riskConnectionService: Symbol('riskConnectionService'),
+    optimizerConnectionService: Symbol('optimizerConnectionService'),
+    partialConnectionService: Symbol('partialConnectionService'),
 };
 const schemaServices$1 = {
     exchangeSchemaService: Symbol('exchangeSchemaService'),
@@ -124,6 +126,7 @@ const schemaServices$1 = {
     walkerSchemaService: Symbol('walkerSchemaService'),
     sizingSchemaService: Symbol('sizingSchemaService'),
     riskSchemaService: Symbol('riskSchemaService'),
+    optimizerSchemaService: Symbol('optimizerSchemaService'),
 };
 const globalServices$1 = {
     exchangeGlobalService: Symbol('exchangeGlobalService'),
@@ -131,6 +134,8 @@ const globalServices$1 = {
     frameGlobalService: Symbol('frameGlobalService'),
     sizingGlobalService: Symbol('sizingGlobalService'),
     riskGlobalService: Symbol('riskGlobalService'),
+    optimizerGlobalService: Symbol('optimizerGlobalService'),
+    partialGlobalService: Symbol('partialGlobalService'),
 };
 const commandServices$1 = {
     liveCommandService: Symbol('liveCommandService'),
@@ -154,6 +159,7 @@ const markdownServices$1 = {
     performanceMarkdownService: Symbol('performanceMarkdownService'),
     walkerMarkdownService: Symbol('walkerMarkdownService'),
     heatMarkdownService: Symbol('heatMarkdownService'),
+    partialMarkdownService: Symbol('partialMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -162,6 +168,10 @@ const validationServices$1 = {
     walkerValidationService: Symbol('walkerValidationService'),
     sizingValidationService: Symbol('sizingValidationService'),
     riskValidationService: Symbol('riskValidationService'),
+    optimizerValidationService: Symbol('optimizerValidationService'),
+};
+const templateServices$1 = {
+    optimizerTemplateService: Symbol('optimizerTemplateService'),
 };
 const TYPES = {
     ...baseServices$1,
@@ -174,6 +184,7 @@ const TYPES = {
     ...logicPublicServices$1,
     ...markdownServices$1,
     ...validationServices$1,
+    ...templateServices$1,
 };
 
 /**
@@ -875,6 +886,12 @@ const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER = "PersistScheduleUtils.usePersistScheduleAdapter";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA = "PersistScheduleUtils.readScheduleData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writeScheduleData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
 const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
 const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
 const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
@@ -940,7 +957,7 @@ const PersistBase = makeExtendable(class {
      * Creates new persistence instance.
      *
      * @param entityName - Unique entity type identifier
-     * @param baseDir - Base directory for all entities (default: ./logs/data)
+     * @param baseDir - Base directory for all entities (default: ./dump/data)
      */
     constructor(entityName, baseDir = join(process.cwd(), "logs/data")) {
         this.entityName = entityName;
@@ -1199,7 +1216,7 @@ class PersistSignalUtils {
         this.PersistSignalFactory = PersistBase;
         this.getSignalStorage = memoize(([strategyName]) => `${strategyName}`, (strategyName) => Reflect.construct(this.PersistSignalFactory, [
             strategyName,
-            `./logs/data/signal/`,
+            `./dump/data/signal/`,
         ]));
         /**
          * Reads persisted signal data for a strategy and symbol.
@@ -1295,7 +1312,7 @@ class PersistRiskUtils {
         this.PersistRiskFactory = PersistBase;
         this.getRiskStorage = memoize(([riskName]) => `${riskName}`, (riskName) => Reflect.construct(this.PersistRiskFactory, [
             riskName,
-            `./logs/data/risk/`,
+            `./dump/data/risk/`,
         ]));
         /**
          * Reads persisted active positions for a risk profile.
@@ -1372,6 +1389,192 @@ class PersistRiskUtils {
  * ```
  */
 const PersistRiskAdapter = new PersistRiskUtils();
+/**
+ * Utility class for managing scheduled signal persistence.
+ *
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations for scheduled signals
+ * - Crash-safe scheduled signal state management
+ *
+ * Used by ClientStrategy for live mode persistence of scheduled signals (_scheduledSignal).
+ */
+class PersistScheduleUtils {
+    constructor() {
+        this.PersistScheduleFactory = PersistBase;
+        this.getScheduleStorage = memoize(([strategyName]) => `${strategyName}`, (strategyName) => Reflect.construct(this.PersistScheduleFactory, [
+            strategyName,
+            `./dump/data/schedule/`,
+        ]));
+        /**
+         * Reads persisted scheduled signal data for a strategy and symbol.
+         *
+         * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
+         * Returns null if no scheduled signal exists.
+         *
+         * @param strategyName - Strategy identifier
+         * @param symbol - Trading pair symbol
+         * @returns Promise resolving to scheduled signal or null
+         */
+        this.readScheduleData = async (strategyName, symbol) => {
+            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            const isInitial = !this.getScheduleStorage.has(strategyName);
+            const stateStorage = this.getScheduleStorage(strategyName);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(symbol)) {
+                return await stateStorage.readValue(symbol);
+            }
+            return null;
+        };
+        /**
+         * Writes scheduled signal data to disk with atomic file writes.
+         *
+         * Called by ClientStrategy.setScheduledSignal() to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param scheduledSignalRow - Scheduled signal data (null to clear)
+         * @param strategyName - Strategy identifier
+         * @param symbol - Trading pair symbol
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeScheduleData = async (scheduledSignalRow, strategyName, symbol) => {
+            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            const isInitial = !this.getScheduleStorage.has(strategyName);
+            const stateStorage = this.getScheduleStorage(strategyName);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(symbol, scheduledSignalRow);
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
+     * ```
+     */
+    usePersistScheduleAdapter(Ctor) {
+        backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        this.PersistScheduleFactory = Ctor;
+    }
+}
+/**
+ * Global singleton instance of PersistScheduleUtils.
+ * Used by ClientStrategy for scheduled signal persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
+ *
+ * // Read scheduled signal
+ * const scheduled = await PersistScheduleAdapter.readScheduleData("my-strategy", "BTCUSDT");
+ *
+ * // Write scheduled signal
+ * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
+ * ```
+ */
+const PersistScheduleAdapter = new PersistScheduleUtils();
+/**
+ * Utility class for managing partial profit/loss levels persistence.
+ *
+ * Features:
+ * - Memoized storage instances per symbol
+ * - Custom adapter support
+ * - Atomic read/write operations for partial data
+ * - Crash-safe partial state management
+ *
+ * Used by ClientPartial for live mode persistence of profit/loss levels.
+ */
+class PersistPartialUtils {
+    constructor() {
+        this.PersistPartialFactory = PersistBase;
+        this.getPartialStorage = memoize(([symbol]) => `${symbol}`, (symbol) => Reflect.construct(this.PersistPartialFactory, [
+            symbol,
+            `./dump/data/partial/`,
+        ]));
+        /**
+         * Reads persisted partial data for a symbol.
+         *
+         * Called by ClientPartial.waitForInit() to restore state.
+         * Returns empty object if no partial data exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @returns Promise resolving to partial data record
+         */
+        this.readPartialData = async (symbol) => {
+            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            const isInitial = !this.getPartialStorage.has(symbol);
+            const stateStorage = this.getPartialStorage(symbol);
+            await stateStorage.waitForInit(isInitial);
+            const PARTIAL_STORAGE_KEY = "levels";
+            if (await stateStorage.hasValue(PARTIAL_STORAGE_KEY)) {
+                return await stateStorage.readValue(PARTIAL_STORAGE_KEY);
+            }
+            return {};
+        };
+        /**
+         * Writes partial data to disk with atomic file writes.
+         *
+         * Called by ClientPartial after profit/loss level changes to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param partialData - Record of signal IDs to partial data
+         * @param symbol - Trading pair symbol
+         * @returns Promise that resolves when write is complete
+         */
+        this.writePartialData = async (partialData, symbol) => {
+            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            const isInitial = !this.getPartialStorage.has(symbol);
+            const stateStorage = this.getPartialStorage(symbol);
+            await stateStorage.waitForInit(isInitial);
+            const PARTIAL_STORAGE_KEY = "levels";
+            await stateStorage.writeValue(PARTIAL_STORAGE_KEY, partialData);
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
+     * ```
+     */
+    usePersistPartialAdapter(Ctor) {
+        backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        this.PersistPartialFactory = Ctor;
+    }
+}
+/**
+ * Global singleton instance of PersistPartialUtils.
+ * Used by ClientPartial for partial profit/loss levels persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
+ *
+ * // Read partial data
+ * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT");
+ *
+ * // Write partial data
+ * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT");
+ * ```
+ */
+const PersistPartialAdapter = new PersistPartialUtils();
 
 /**
  * Global signal emitter for all trading events (live + backtest).
@@ -1412,7 +1615,12 @@ const doneWalkerSubject = new Subject();
  * Progress emitter for backtest execution progress.
  * Emits progress updates during backtest execution.
  */
-const progressEmitter = new Subject();
+const progressBacktestEmitter = new Subject();
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+const progressWalkerEmitter = new Subject();
 /**
  * Performance emitter for execution metrics.
  * Emits performance metrics for profiling and bottleneck detection.
@@ -1428,11 +1636,26 @@ const walkerEmitter = new Subject();
  * Emits when all strategies have been tested and final results are available.
  */
 const walkerCompleteSubject = new Subject();
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ */
+const walkerStopSubject = new Subject();
 /**
  * Validation emitter for risk validation errors.
  * Emits when risk validation functions throw errors during signal checking.
  */
 const validationSubject = new Subject();
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+const partialProfitSubject = new Subject();
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+const partialLossSubject = new Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1440,14 +1663,18 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneLiveSubject: doneLiveSubject,
     doneWalkerSubject: doneWalkerSubject,
     errorEmitter: errorEmitter,
+    partialLossSubject: partialLossSubject,
+    partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
-    progressEmitter: progressEmitter,
+    progressBacktestEmitter: progressBacktestEmitter,
+    progressWalkerEmitter: progressWalkerEmitter,
     signalBacktestEmitter: signalBacktestEmitter,
     signalEmitter: signalEmitter,
     signalLiveEmitter: signalLiveEmitter,
     validationSubject: validationSubject,
     walkerCompleteSubject: walkerCompleteSubject,
-    walkerEmitter: walkerEmitter
+    walkerEmitter: walkerEmitter,
+    walkerStopSubject: walkerStopSubject
 });
 
 const INTERVAL_MINUTES$1 = {
@@ -1460,6 +1687,25 @@ const INTERVAL_MINUTES$1 = {
 };
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     const errors = [];
+    // ПРОВЕРКА ОБЯЗАТЕЛЬНЫХ ПОЛЕЙ ISignalRow
+    if (signal.id === undefined || signal.id === null || signal.id === '') {
+        errors.push('id is required and must be a non-empty string');
+    }
+    if (signal.exchangeName === undefined || signal.exchangeName === null || signal.exchangeName === '') {
+        errors.push('exchangeName is required');
+    }
+    if (signal.strategyName === undefined || signal.strategyName === null || signal.strategyName === '') {
+        errors.push('strategyName is required');
+    }
+    if (signal.symbol === undefined || signal.symbol === null || signal.symbol === '') {
+        errors.push('symbol is required and must be a non-empty string');
+    }
+    if (signal._isScheduled === undefined || signal._isScheduled === null) {
+        errors.push('_isScheduled is required');
+    }
+    if (signal.position === undefined || signal.position === null) {
+        errors.push('position is required and must be "long" or "short"');
+    }
     // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
     if (!isFinite(currentPrice)) {
         errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
@@ -1709,26 +1955,42 @@ const GET_AVG_PRICE_FN = (candles) => {
         ? candles.reduce((acc, c) => acc + c.close, 0) / candles.length
         : sumPriceVolume / totalVolume;
 };
-const WAIT_FOR_INIT_FN$1 = async (self) => {
+const WAIT_FOR_INIT_FN$2 = async (self) => {
     self.params.logger.debug("ClientStrategy waitForInit");
     if (self.params.execution.context.backtest) {
         return;
     }
+    // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.strategyName, self.params.execution.context.symbol);
-    if (!pendingSignal) {
-        return;
-    }
-    if (pendingSignal.exchangeName !== self.params.method.context.exchangeName) {
-        return;
-    }
-    if (pendingSignal.strategyName !== self.params.method.context.strategyName) {
-        return;
+    if (pendingSignal) {
+        if (pendingSignal.exchangeName !== self.params.method.context.exchangeName) {
+            return;
+        }
+        if (pendingSignal.strategyName !== self.params.method.context.strategyName) {
+            return;
+        }
+        self._pendingSignal = pendingSignal;
+        // Call onActive callback for restored signal
+        if (self.params.callbacks?.onActive) {
+            const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+            self.params.callbacks.onActive(self.params.execution.context.symbol, pendingSignal, currentPrice, self.params.execution.context.backtest);
+        }
     }
-    self._pendingSignal = pendingSignal;
-    // Call onActive callback for restored signal
-    if (self.params.callbacks?.onActive) {
-        const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-        self.params.callbacks.onActive(self.params.execution.context.symbol, pendingSignal, currentPrice, self.params.execution.context.backtest);
+    // Restore scheduled signal
+    const scheduledSignal = await PersistScheduleAdapter.readScheduleData(self.params.strategyName, self.params.execution.context.symbol);
+    if (scheduledSignal) {
+        if (scheduledSignal.exchangeName !== self.params.method.context.exchangeName) {
+            return;
+        }
+        if (scheduledSignal.strategyName !== self.params.method.context.strategyName) {
+            return;
+        }
+        self._scheduledSignal = scheduledSignal;
+        // Call onSchedule callback for restored scheduled signal
+        if (self.params.callbacks?.onSchedule) {
+            const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+            self.params.callbacks.onSchedule(self.params.execution.context.symbol, scheduledSignal, currentPrice, self.params.execution.context.backtest);
+        }
     }
 };
 const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice) => {
@@ -1745,7 +2007,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         elapsedMinutes: Math.floor(elapsedTime / 60000),
         maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
     });
-    self._scheduledSignal = null;
+    await self.setScheduledSignal(null);
     if (self.params.callbacks?.onCancel) {
         self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, currentPrice, self.params.execution.context.backtest);
     }
@@ -1800,7 +2062,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         averagePrice: currentPrice,
         priceStopLoss: scheduled.priceStopLoss,
     });
-    self._scheduledSignal = null;
+    await self.setScheduledSignal(null);
     const result = {
         action: "idle",
         signal: null,
@@ -1821,7 +2083,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
         });
-        self._scheduledSignal = null;
+        await self.setScheduledSignal(null);
         return null;
     }
     // В LIVE режиме activationTimestamp - это текущее время при tick()
@@ -1849,10 +2111,10 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
         });
-        self._scheduledSignal = null;
+        await self.setScheduledSignal(null);
         return null;
     }
-    self._scheduledSignal = null;
+    await self.setScheduledSignal(null);
     // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации
     const activatedSignal = {
         ...scheduled,
@@ -1990,6 +2252,8 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
     if (self.params.callbacks?.onClose) {
         self.params.callbacks.onClose(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
     }
+    // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+    await self.params.partial.clear(self.params.execution.context.symbol, signal, currentPrice);
     await self.params.risk.removeSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
@@ -2012,6 +2276,34 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
     return result;
 };
 const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
+    // Calculate revenue percentage for partial fill/loss callbacks
+    {
+        let revenuePercent = 0;
+        if (signal.position === "long") {
+            // For long: positive if current > open, negative if current < open
+            revenuePercent = ((currentPrice - signal.priceOpen) / signal.priceOpen) * 100;
+        }
+        else if (signal.position === "short") {
+            // For short: positive if current < open, negative if current > open
+            revenuePercent = ((signal.priceOpen - currentPrice) / signal.priceOpen) * 100;
+        }
+        // Call onPartialProfit if revenue is positive (but not reached TP yet)
+        if (revenuePercent > 0) {
+            // КРИТИЧНО: Вызываем ClientPartial для отслеживания уровней
+            await self.params.partial.profit(self.params.execution.context.symbol, signal, currentPrice, revenuePercent, self.params.execution.context.backtest, self.params.execution.context.when);
+            if (self.params.callbacks?.onPartialProfit) {
+                self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, currentPrice, revenuePercent, self.params.execution.context.backtest);
+            }
+        }
+        // Call onPartialLoss if revenue is negative (but not hit SL yet)
+        if (revenuePercent < 0) {
+            // КРИТИЧНО: Вызываем ClientPartial для отслеживания уровней
+            await self.params.partial.loss(self.params.execution.context.symbol, signal, currentPrice, revenuePercent, self.params.execution.context.backtest, self.params.execution.context.when);
+            if (self.params.callbacks?.onPartialLoss) {
+                self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, currentPrice, revenuePercent, self.params.execution.context.backtest);
+            }
+        }
+    }
     const result = {
         action: "active",
         signal: signal,
@@ -2050,7 +2342,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         averagePrice,
         priceStopLoss: scheduled.priceStopLoss,
     });
-    self._scheduledSignal = null;
+    await self.setScheduledSignal(null);
     if (self.params.callbacks?.onCancel) {
         self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, averagePrice, self.params.execution.context.backtest);
     }
@@ -2075,7 +2367,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
         });
-        self._scheduledSignal = null;
+        await self.setScheduledSignal(null);
         return false;
     }
     // В BACKTEST режиме activationTimestamp - это candle.timestamp + 60*1000
@@ -2100,10 +2392,10 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
         });
-        self._scheduledSignal = null;
+        await self.setScheduledSignal(null);
         return false;
     }
-    self._scheduledSignal = null;
+    await self.setScheduledSignal(null);
     // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации в backtest
     const activatedSignal = {
         ...scheduled,
@@ -2139,6 +2431,8 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     if (self.params.callbacks?.onClose) {
         self.params.callbacks.onClose(self.params.execution.context.symbol, signal, averagePrice, self.params.execution.context.backtest);
     }
+    // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+    await self.params.partial.clear(self.params.execution.context.symbol, signal, averagePrice);
     await self.params.risk.removeSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
@@ -2280,6 +2574,33 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
             }
             return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
         }
+        // Call onPartialProfit/onPartialLoss callbacks during backtest candle processing
+        // Calculate revenue percentage
+        {
+            let revenuePercent = 0;
+            if (signal.position === "long") {
+                revenuePercent = ((averagePrice - signal.priceOpen) / signal.priceOpen) * 100;
+            }
+            else if (signal.position === "short") {
+                revenuePercent = ((signal.priceOpen - averagePrice) / signal.priceOpen) * 100;
+            }
+            // Call onPartialProfit if revenue is positive (but not reached TP yet)
+            if (revenuePercent > 0) {
+                // КРИТИЧНО: Вызываем ClientPartial для отслеживания уровней
+                await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, revenuePercent, self.params.execution.context.backtest, self.params.execution.context.when);
+                if (self.params.callbacks?.onPartialProfit) {
+                    self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, revenuePercent, self.params.execution.context.backtest);
+                }
+            }
+            // Call onPartialLoss if revenue is negative (but not hit SL yet)
+            if (revenuePercent < 0) {
+                // КРИТИЧНО: Вызываем ClientPartial для отслеживания уровней
+                await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, revenuePercent, self.params.execution.context.backtest, self.params.execution.context.when);
+                if (self.params.callbacks?.onPartialLoss) {
+                    self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, revenuePercent, self.params.execution.context.backtest);
+                }
+            }
+        }
     }
     return null;
 };
@@ -2326,7 +2647,7 @@ class ClientStrategy {
          *
          * @returns Promise that resolves when initialization is complete
          */
-        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN$1(this));
+        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN$2(this));
     }
     /**
      * Updates pending signal and persists to disk in live mode.
@@ -2352,6 +2673,25 @@ class ClientStrategy {
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
     }
+    /**
+     * Updates scheduled signal and persists to disk in live mode.
+     *
+     * Centralized method for all scheduled signal state changes.
+     * Uses atomic file writes to prevent corruption.
+     *
+     * @param scheduledSignal - New scheduled signal state (null to clear)
+     * @returns Promise that resolves when update is complete
+     */
+    async setScheduledSignal(scheduledSignal) {
+        this.params.logger.debug("ClientStrategy setScheduledSignal", {
+            scheduledSignal,
+        });
+        this._scheduledSignal = scheduledSignal;
+        if (this.params.execution.context.backtest) {
+            return;
+        }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.strategyName, this.params.execution.context.symbol);
+    }
     /**
      * Retrieves the current pending signal.
      * If no signal is pending, returns null.
@@ -2426,7 +2766,7 @@ class ClientStrategy {
             const signal = await GET_SIGNAL_FN(this);
             if (signal) {
                 if (signal._isScheduled === true) {
-                    this._scheduledSignal = signal;
+                    await this.setScheduledSignal(signal);
                     return await OPEN_NEW_SCHEDULED_SIGNAL_FN(this, this._scheduledSignal);
                 }
                 await this.setPendingSignal(signal);
@@ -2602,7 +2942,7 @@ class ClientStrategy {
         this._isStopped = true;
         // Clear scheduled signal if exists
         if (this._scheduledSignal) {
-            this._scheduledSignal = null;
+            await this.setScheduledSignal(null);
         }
     }
 }
@@ -2641,6 +2981,7 @@ class StrategyConnectionService {
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.methodContextService = inject(TYPES.methodContextService);
+        this.partialConnectionService = inject(TYPES.partialConnectionService);
         /**
          * Retrieves memoized ClientStrategy instance for given strategy name.
          *
@@ -2657,6 +2998,7 @@ class StrategyConnectionService {
                 execution: this.executionContextService,
                 method: this.methodContextService,
                 logger: this.loggerService,
+                partial: this.partialConnectionService,
                 exchange: this.exchangeConnectionService,
                 risk: riskName ? this.riskConnectionService.getRisk(riskName) : NOOP_RISK,
                 riskName,
@@ -2669,11 +3011,14 @@ class StrategyConnectionService {
          * Retrieves the currently active pending signal for the strategy.
          * If no active signal exists, returns null.
          * Used internally for monitoring TP/SL and time expiration.
+         *
+         * @param strategyName - Name of strategy to get pending signal for
+         *
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async () => {
+        this.getPendingSignal = async (strategyName) => {
             this.loggerService.log("strategyConnectionService getPendingSignal");
-            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            const strategy = await this.getStrategy(strategyName);
             return await strategy.getPendingSignal();
         };
         /**
@@ -3140,7 +3485,7 @@ const DO_VALIDATION_FN = trycatch(async (validation, params) => {
  * Uses singleshot pattern to ensure it only runs once.
  * This function is exported for use in tests or other modules.
  */
-const WAIT_FOR_INIT_FN = async (self) => {
+const WAIT_FOR_INIT_FN$1 = async (self) => {
     self.params.logger.debug("ClientRisk waitForInit");
     const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName);
     self._activePositions = new Map(persistedPositions);
@@ -3171,7 +3516,7 @@ class ClientRisk {
          * Uses singleshot pattern to ensure initialization happens exactly once.
          * Skips persistence in backtest mode.
          */
-        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN(this));
+        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN$1(this));
         /**
          * Checks if a signal should be allowed based on risk limits.
          *
@@ -3588,20 +3933,12 @@ class StrategyGlobalService {
          * @param backtest - Whether running in backtest mode
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, when, backtest) => {
+        this.getPendingSignal = async (strategyName) => {
             this.loggerService.log("strategyGlobalService getPendingSignal", {
-                symbol,
-                when,
-                backtest,
+                strategyName,
             });
             await this.validate(this.methodContextService.context.strategyName);
-            return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.getPendingSignal();
-            }, {
-                symbol,
-                when,
-                backtest,
-            });
+            return await this.strategyConnectionService.getPendingSignal(strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -4354,7 +4691,7 @@ class BacktestLogicPrivateService {
             const when = timeframes[i];
             // Emit progress event if context is available
             {
-                await progressEmitter.next({
+                await progressBacktestEmitter.next({
                     exchangeName: this.methodContextService.context.exchangeName,
                     strategyName: this.methodContextService.context.strategyName,
                     symbol,
@@ -4488,7 +4825,7 @@ class BacktestLogicPrivateService {
         }
         // Emit final progress event (100%)
         {
-            await progressEmitter.next({
+            await progressBacktestEmitter.next({
                 exchangeName: this.methodContextService.context.exchangeName,
                 strategyName: this.methodContextService.context.strategyName,
                 symbol,
@@ -4605,6 +4942,7 @@ class LiveLogicPrivateService {
     }
 }
 
+const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -4662,6 +5000,10 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
+        const listenStop = walkerStopSubject
+            .filter((walkerName) => walkerName === context.walkerName)
+            .map(() => CANCEL_SYMBOL)
+            .toPromise();
         // Run backtest for each strategy
         for (const strategyName of strategies) {
             // Call onStrategyStart callback if provided
@@ -4677,7 +5019,16 @@ class WalkerLogicPrivateService {
                 exchangeName: context.exchangeName,
                 frameName: context.frameName,
             });
-            await resolveDocuments(iterator);
+            const result = await Promise.race([
+                await resolveDocuments(iterator),
+                listenStop,
+            ]);
+            if (result === CANCEL_SYMBOL) {
+                this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
+                    context,
+                });
+                break;
+            }
             this.loggerService.info("walkerLogicPrivateService backtest complete", {
                 strategyName,
                 symbol,
@@ -4715,6 +5066,16 @@ class WalkerLogicPrivateService {
                 strategiesTested,
                 totalStrategies: strategies.length,
             };
+            // Emit progress event
+            await progressWalkerEmitter.next({
+                walkerName: context.walkerName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                symbol,
+                totalStrategies: strategies.length,
+                processedStrategies: strategiesTested,
+                progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
+            });
             // Call onStrategyComplete callback if provided
             if (walkerSchema.callbacks?.onStrategyComplete) {
                 walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
@@ -5060,7 +5421,7 @@ function isUnsafe$3(value) {
     }
     return false;
 }
-const columns$3 = [
+const columns$4 = [
     {
         key: "signalId",
         label: "Signal ID",
@@ -5138,7 +5499,7 @@ const columns$3 = [
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$3 = class ReportStorage {
+let ReportStorage$4 = class ReportStorage {
     constructor() {
         /** Internal list of all closed signals for this strategy */
         this._signalList = [];
@@ -5228,9 +5589,9 @@ let ReportStorage$3 = class ReportStorage {
         if (stats.totalSignals === 0) {
             return str.newline(`# Backtest Report: ${strategyName}`, "", "No signals closed yet.");
         }
-        const header = columns$3.map((col) => col.label);
-        const separator = columns$3.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => columns$3.map((col) => col.format(closedSignal)));
+        const header = columns$4.map((col) => col.label);
+        const separator = columns$4.map(() => "---");
+        const rows = this._signalList.map((closedSignal) => columns$4.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return str.newline(`# Backtest Report: ${strategyName}`, "", table, "", `**Total signals:** ${stats.totalSignals}`, `**Closed signals:** ${stats.totalSignals}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
@@ -5239,9 +5600,9 @@ let ReportStorage$3 = class ReportStorage {
      * Saves strategy report to disk.
      *
      * @param strategyName - Strategy name
-     * @param path - Directory path to save report (default: "./logs/backtest")
+     * @param path - Directory path to save report (default: "./dump/backtest")
      */
-    async dump(strategyName, path = "./logs/backtest") {
+    async dump(strategyName, path = "./dump/backtest") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
@@ -5291,7 +5652,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -5369,20 +5730,20 @@ class BacktestMarkdownService {
          * Delegates to ReportStorage.dump().
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Directory path to save report (default: "./logs/backtest")
+         * @param path - Directory path to save report (default: "./dump/backtest")
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
          *
-         * // Save to default path: ./logs/backtest/my-strategy.md
+         * // Save to default path: ./dump/backtest/my-strategy.md
          * await service.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
          * await service.dump("my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/backtest") => {
+        this.dump = async (strategyName, path = "./dump/backtest") => {
             this.loggerService.log("backtestMarkdownService dump", {
                 strategyName,
                 path,
@@ -5450,7 +5811,7 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$2 = [
+const columns$3 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -5524,12 +5885,12 @@ const columns$2 = [
     },
 ];
 /** Maximum number of events to store in live trading reports */
-const MAX_EVENTS$2 = 250;
+const MAX_EVENTS$3 = 250;
 /**
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-let ReportStorage$2 = class ReportStorage {
+let ReportStorage$3 = class ReportStorage {
     constructor() {
         /** Internal list of all tick events for this strategy */
         this._eventList = [];
@@ -5557,7 +5918,7 @@ let ReportStorage$2 = class ReportStorage {
         }
         {
             this._eventList.push(newEvent);
-            if (this._eventList.length > MAX_EVENTS$2) {
+            if (this._eventList.length > MAX_EVENTS$3) {
                 this._eventList.shift();
             }
         }
@@ -5581,7 +5942,7 @@ let ReportStorage$2 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$2) {
+        if (this._eventList.length > MAX_EVENTS$3) {
             this._eventList.shift();
         }
     }
@@ -5613,7 +5974,7 @@ let ReportStorage$2 = class ReportStorage {
         else {
             this._eventList.push(newEvent);
             // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$2) {
+            if (this._eventList.length > MAX_EVENTS$3) {
                 this._eventList.shift();
             }
         }
@@ -5651,7 +6012,7 @@ let ReportStorage$2 = class ReportStorage {
         else {
             this._eventList.push(newEvent);
             // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$2) {
+            if (this._eventList.length > MAX_EVENTS$3) {
                 this._eventList.shift();
             }
         }
@@ -5748,9 +6109,9 @@ let ReportStorage$2 = class ReportStorage {
         if (stats.totalEvents === 0) {
             return str.newline(`# Live Trading Report: ${strategyName}`, "", "No events recorded yet.");
         }
-        const header = columns$2.map((col) => col.label);
-        const separator = columns$2.map(() => "---");
-        const rows = this._eventList.map((event) => columns$2.map((col) => col.format(event)));
+        const header = columns$3.map((col) => col.label);
+        const separator = columns$3.map(() => "---");
+        const rows = this._eventList.map((event) => columns$3.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return str.newline(`# Live Trading Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Closed signals:** ${stats.totalClosed}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
@@ -5759,9 +6120,9 @@ let ReportStorage$2 = class ReportStorage {
      * Saves strategy report to disk.
      *
      * @param strategyName - Strategy name
-     * @param path - Directory path to save report (default: "./logs/live")
+     * @param path - Directory path to save report (default: "./dump/live")
      */
-    async dump(strategyName, path = "./logs/live") {
+    async dump(strategyName, path = "./dump/live") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
@@ -5814,7 +6175,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -5902,20 +6263,20 @@ class LiveMarkdownService {
          * Delegates to ReportStorage.dump().
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Directory path to save report (default: "./logs/live")
+         * @param path - Directory path to save report (default: "./dump/live")
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
          *
-         * // Save to default path: ./logs/live/my-strategy.md
+         * // Save to default path: ./dump/live/my-strategy.md
          * await service.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
          * await service.dump("my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/live") => {
+        this.dump = async (strategyName, path = "./dump/live") => {
             this.loggerService.log("liveMarkdownService dump", {
                 strategyName,
                 path,
@@ -5965,7 +6326,7 @@ class LiveMarkdownService {
     }
 }
 
-const columns$1 = [
+const columns$2 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -6023,12 +6384,12 @@ const columns$1 = [
     },
 ];
 /** Maximum number of events to store in schedule reports */
-const MAX_EVENTS$1 = 250;
+const MAX_EVENTS$2 = 250;
 /**
  * Storage class for accumulating scheduled signal events per strategy.
  * Maintains a chronological list of scheduled and cancelled events.
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     constructor() {
         /** Internal list of all scheduled events for this strategy */
         this._eventList = [];
@@ -6052,7 +6413,7 @@ let ReportStorage$1 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$1) {
+        if (this._eventList.length > MAX_EVENTS$2) {
             this._eventList.shift();
         }
     }
@@ -6088,7 +6449,7 @@ let ReportStorage$1 = class ReportStorage {
         else {
             this._eventList.push(newEvent);
             // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$1) {
+            if (this._eventList.length > MAX_EVENTS$2) {
                 this._eventList.shift();
             }
         }
@@ -6140,9 +6501,9 @@ let ReportStorage$1 = class ReportStorage {
         if (stats.totalEvents === 0) {
             return str.newline(`# Scheduled Signals Report: ${strategyName}`, "", "No scheduled signals recorded yet.");
         }
-        const header = columns$1.map((col) => col.label);
-        const separator = columns$1.map(() => "---");
-        const rows = this._eventList.map((event) => columns$1.map((col) => col.format(event)));
+        const header = columns$2.map((col) => col.label);
+        const separator = columns$2.map(() => "---");
+        const rows = this._eventList.map((event) => columns$2.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
         return str.newline(`# Scheduled Signals Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Scheduled signals:** ${stats.totalScheduled}`, `**Cancelled signals:** ${stats.totalCancelled}`, `**Cancellation rate:** ${stats.cancellationRate === null ? "N/A" : `${stats.cancellationRate.toFixed(2)}% (lower is better)`}`, `**Average wait time (cancelled):** ${stats.avgWaitTime === null ? "N/A" : `${stats.avgWaitTime.toFixed(2)} minutes`}`);
@@ -6151,9 +6512,9 @@ let ReportStorage$1 = class ReportStorage {
      * Saves strategy report to disk.
      *
      * @param strategyName - Strategy name
-     * @param path - Directory path to save report (default: "./logs/schedule")
+     * @param path - Directory path to save report (default: "./dump/schedule")
      */
-    async dump(strategyName, path = "./logs/schedule") {
+    async dump(strategyName, path = "./dump/schedule") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
@@ -6197,7 +6558,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$1());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
         /**
          * Processes tick events and accumulates scheduled/cancelled events.
          * Should be called from signalLiveEmitter subscription.
@@ -6272,20 +6633,20 @@ class ScheduleMarkdownService {
          * Delegates to ReportStorage.dump().
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Directory path to save report (default: "./logs/schedule")
+         * @param path - Directory path to save report (default: "./dump/schedule")
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
          *
-         * // Save to default path: ./logs/schedule/my-strategy.md
+         * // Save to default path: ./dump/schedule/my-strategy.md
          * await service.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
          * await service.dump("my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/schedule") => {
+        this.dump = async (strategyName, path = "./dump/schedule") => {
             this.loggerService.log("scheduleMarkdownService dump", {
                 strategyName,
                 path,
@@ -6345,7 +6706,7 @@ function percentile(sortedArray, p) {
     return sortedArray[Math.max(0, index)];
 }
 /** Maximum number of performance events to store per strategy */
-const MAX_EVENTS = 10000;
+const MAX_EVENTS$1 = 10000;
 /**
  * Storage class for accumulating performance metrics per strategy.
  * Maintains a list of all performance events and provides aggregated statistics.
@@ -6363,7 +6724,7 @@ class PerformanceStorage {
     addEvent(event) {
         this._events.push(event);
         // Trim queue if exceeded MAX_EVENTS (keep most recent)
-        if (this._events.length > MAX_EVENTS) {
+        if (this._events.length > MAX_EVENTS$1) {
             this._events.shift();
         }
     }
@@ -6502,7 +6863,7 @@ class PerformanceStorage {
      * @param strategyName - Strategy name
      * @param path - Directory path to save report
      */
-    async dump(strategyName, path = "./logs/performance") {
+    async dump(strategyName, path = "./dump/performance") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
@@ -6615,14 +6976,14 @@ class PerformanceMarkdownService {
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/performance/my-strategy.md
+         * // Save to default path: ./dump/performance/my-strategy.md
          * await performanceService.dump("my-strategy");
          *
          * // Save to custom path
          * await performanceService.dump("my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/performance") => {
+        this.dump = async (strategyName, path = "./dump/performance") => {
             this.loggerService.log("performanceMarkdownService dump", {
                 strategyName,
                 path,
@@ -6684,7 +7045,7 @@ function formatMetric(value) {
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
  */
-class ReportStorage {
+let ReportStorage$1 = class ReportStorage {
     constructor(walkerName) {
         this.walkerName = walkerName;
         /** Walker metadata (set from first addResult call) */
@@ -6752,9 +7113,9 @@ class ReportStorage {
      * @param symbol - Trading symbol
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
-     * @param path - Directory path to save report (default: "./logs/walker")
+     * @param path - Directory path to save report (default: "./dump/walker")
      */
-    async dump(symbol, metric, context, path = "./logs/walker") {
+    async dump(symbol, metric, context, path = "./dump/walker") {
         const markdown = await this.getReport(symbol, metric, context);
         try {
             const dir = join(process.cwd(), path);
@@ -6768,7 +7129,7 @@ class ReportStorage {
             console.error(`Failed to save walker report:`, error);
         }
     }
-}
+};
 /**
  * Service for generating and saving walker markdown reports.
  *
@@ -6793,7 +7154,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage(walkerName));
+        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$1(walkerName));
         /**
          * Processes walker progress events and accumulates strategy results.
          * Should be called from walkerEmitter.
@@ -6876,20 +7237,20 @@ class WalkerMarkdownService {
          * @param symbol - Trading symbol
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
-         * @param path - Directory path to save report (default: "./logs/walker")
+         * @param path - Directory path to save report (default: "./dump/walker")
          *
          * @example
          * ```typescript
          * const service = new WalkerMarkdownService();
          *
-         * // Save to default path: ./logs/walker/my-walker.md
+         * // Save to default path: ./dump/walker/my-walker.md
          * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
          *
          * // Save to custom path: ./custom/path/my-walker.md
          * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" }, "./custom/path");
          * ```
          */
-        this.dump = async (walkerName, symbol, metric, context, path = "./logs/walker") => {
+        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker") => {
             this.loggerService.log("walkerMarkdownService dump", {
                 walkerName,
                 symbol,
@@ -6964,7 +7325,7 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns = [
+const columns$1 = [
     {
         key: "symbol",
         label: "Symbol",
@@ -7260,9 +7621,9 @@ class HeatmapStorage {
         if (data.symbols.length === 0) {
             return str.newline(`# Portfolio Heatmap: ${strategyName}`, "", "*No data available*");
         }
-        const header = columns.map((col) => col.label);
-        const separator = columns.map(() => "---");
-        const rows = data.symbols.map((row) => columns.map((col) => col.format(row)));
+        const header = columns$1.map((col) => col.label);
+        const separator = columns$1.map(() => "---");
+        const rows = data.symbols.map((row) => columns$1.map((col) => col.format(row)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
         return str.newline(`# Portfolio Heatmap: ${strategyName}`, "", `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%+.2f%%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio, "%.2f") : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`, "", table);
@@ -7271,9 +7632,9 @@ class HeatmapStorage {
      * Saves heatmap report to disk.
      *
      * @param strategyName - Strategy name for filename
-     * @param path - Directory path to save report (default: "./logs/heatmap")
+     * @param path - Directory path to save report (default: "./dump/heatmap")
      */
-    async dump(strategyName, path = "./logs/heatmap") {
+    async dump(strategyName, path = "./dump/heatmap") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
@@ -7404,20 +7765,20 @@ class HeatMarkdownService {
          * Default filename: {strategyName}.md
          *
          * @param strategyName - Strategy name to save heatmap report for
-         * @param path - Optional directory path to save report (default: "./logs/heatmap")
+         * @param path - Optional directory path to save report (default: "./dump/heatmap")
          *
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
          *
-         * // Save to default path: ./logs/heatmap/my-strategy.md
+         * // Save to default path: ./dump/heatmap/my-strategy.md
          * await service.dump("my-strategy");
          *
          * // Save to custom path: ./reports/my-strategy.md
          * await service.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/heatmap") => {
+        this.dump = async (strategyName, path = "./dump/heatmap") => {
             this.loggerService.log(HEATMAP_METHOD_NAME_DUMP, {
                 strategyName,
                 path,
@@ -7849,34 +8210,2297 @@ class RiskValidationService {
     }
 }
 
-{
-    provide(TYPES.loggerService, () => new LoggerService());
-}
-{
-    provide(TYPES.executionContextService, () => new ExecutionContextService());
-    provide(TYPES.methodContextService, () => new MethodContextService());
-}
-{
-    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
-    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
-    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
-    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
-    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
-}
-{
-    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
-    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
-    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
-    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
-    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
-    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
-}
-{
-    provide(TYPES.exchangeGlobalService, () => new ExchangeGlobalService());
+/**
+ * Default template service for generating optimizer code snippets.
+ * Implements all IOptimizerTemplate methods with Ollama LLM integration.
+ *
+ * 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
+ *
+ * Can be partially overridden in optimizer schema configuration.
+ */
+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 {`,
+                `    addExchange,`,
+                `    addStrategy,`,
+                `    addFrame,`,
+                `    addWalker,`,
+                `    Walker,`,
+                `    Backtest,`,
+                `    getCandles,`,
+                `    listenSignalBacktest,`,
+                `    listenWalkerComplete,`,
+                `    listenDoneBacktest,`,
+                `    listenBacktestProgress,`,
+                `    listenWalkerProgress,`,
+                `    listenError,`,
+                `} from "backtest-kit";`,
+                `import { promises as fs } from "fs";`,
+                `import { v4 as uuid } from "uuid";`,
+                `import path from "path";`,
+                ``,
+                `const WARN_KB = 100;`
+            ].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 [
+                `addWalker({`,
+                `    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,
+            });
+            // 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(prompt)
+                .replace(/\\/g, '\\\\')
+                .replace(/`/g, '\\`')
+                .replace(/\$/g, '\\$');
+            return [
+                `addStrategy({`,
+                `    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);`,
+                ``,
+                `        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 [
+                `addExchange({`,
+                `    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 [
+                `addFrame({`,
+                `    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("${escapedSymbol}", results.walkerName);`,
+                `});`,
+                ``,
+                `listenDoneBacktest((event) => {`,
+                `    console.log("Backtest completed:", event.symbol);`,
+                `    Backtest.dump(event.strategyName);`,
+                `});`,
+                ``,
+                `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";`,
+                ``,
+                `        {`,
+                `            summary += "\\n";`,
+                `            summary += \`**ResultId**: \${resultId}\\n\`;`,
+                `            summary += "\\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";`,
+                `            });`,
+                `        }`,
+                ``,
+                `        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");
+        };
+        /**
+         * Generates text() helper for LLM text generation.
+         * Uses Ollama gpt-oss:20b 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", {
+                symbol,
+            });
+            // 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: "gpt-oss:20b",`,
+                `        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");
+        };
+        /**
+         * 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", {
+                symbol,
+            });
+            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: "gpt-oss:20b",`,
+                `        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");
+        };
+    }
+}
+
+/**
+ * Service for managing optimizer schema registration and retrieval.
+ * Provides validation and registry management for optimizer configurations.
+ *
+ * Uses ToolRegistry for immutable schema storage.
+ */
+class OptimizerSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._registry = new ToolRegistry("optimizerSchema");
+        /**
+         * Registers a new optimizer schema.
+         * Validates required fields before registration.
+         *
+         * @param key - Unique optimizer name
+         * @param value - Optimizer schema configuration
+         * @throws Error if schema validation fails
+         */
+        this.register = (key, value) => {
+            this.loggerService.log(`optimizerSchemaService register`, { key });
+            this.validateShallow(value);
+            this._registry = this._registry.register(key, value);
+        };
+        /**
+         * Validates optimizer schema structure.
+         * Checks required fields: optimizerName, rangeTrain, source, getPrompt.
+         *
+         * @param optimizerSchema - Schema to validate
+         * @throws Error if validation fails
+         */
+        this.validateShallow = (optimizerSchema) => {
+            this.loggerService.log(`optimizerTemplateService validateShallow`, {
+                optimizerSchema,
+            });
+            if (typeof optimizerSchema.optimizerName !== "string") {
+                throw new Error(`optimizer template validation failed: missing optimizerName`);
+            }
+            if (!Array.isArray(optimizerSchema.rangeTrain) || optimizerSchema.rangeTrain.length === 0) {
+                throw new Error(`optimizer template validation failed: rangeTrain must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+            if (!Array.isArray(optimizerSchema.source) || optimizerSchema.source.length === 0) {
+                throw new Error(`optimizer template validation failed: source must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+            if (typeof optimizerSchema.getPrompt !== "function") {
+                throw new Error(`optimizer template validation failed: getPrompt must be a function for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+        };
+        /**
+         * Partially overrides an existing optimizer schema.
+         * Merges provided values with existing schema.
+         *
+         * @param key - Optimizer name to override
+         * @param value - Partial schema values to merge
+         * @returns Updated complete schema
+         * @throws Error if optimizer not found
+         */
+        this.override = (key, value) => {
+            this.loggerService.log(`optimizerSchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        /**
+         * Retrieves optimizer schema by name.
+         *
+         * @param key - Optimizer name
+         * @returns Complete optimizer schema
+         * @throws Error if optimizer not found
+         */
+        this.get = (key) => {
+            this.loggerService.log(`optimizerSchemaService get`, { key });
+            return this._registry.get(key);
+        };
+    }
+}
+
+/**
+ * Service for validating optimizer existence and managing optimizer registry.
+ * Maintains a Map of registered optimizers for validation purposes.
+ *
+ * Uses memoization for efficient repeated validation checks.
+ */
+class OptimizerValidationService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._optimizerMap = new Map();
+        /**
+         * Adds optimizer to validation registry.
+         * Prevents duplicate optimizer names.
+         *
+         * @param optimizerName - Unique optimizer identifier
+         * @param optimizerSchema - Complete optimizer schema
+         * @throws Error if optimizer with same name already exists
+         */
+        this.addOptimizer = (optimizerName, optimizerSchema) => {
+            this.loggerService.log("optimizerValidationService addOptimizer", {
+                optimizerName,
+                optimizerSchema,
+            });
+            if (this._optimizerMap.has(optimizerName)) {
+                throw new Error(`optimizer ${optimizerName} already exist`);
+            }
+            this._optimizerMap.set(optimizerName, optimizerSchema);
+        };
+        /**
+         * Validates that optimizer exists in registry.
+         * Memoized for performance on repeated checks.
+         *
+         * @param optimizerName - Optimizer name to validate
+         * @param source - Source method name for error messages
+         * @throws Error if optimizer not found
+         */
+        this.validate = memoize(([optimizerName]) => optimizerName, (optimizerName, source) => {
+            this.loggerService.log("optimizerValidationService validate", {
+                optimizerName,
+                source,
+            });
+            const optimizer = this._optimizerMap.get(optimizerName);
+            if (!optimizer) {
+                throw new Error(`optimizer ${optimizerName} not found source=${source}`);
+            }
+            return true;
+        });
+        /**
+         * Lists all registered optimizer schemas.
+         *
+         * @returns Array of all optimizer schemas
+         */
+        this.list = async () => {
+            this.loggerService.log("optimizerValidationService list");
+            return Array.from(this._optimizerMap.values());
+        };
+    }
+}
+
+const METHOD_NAME_GET_DATA = "optimizerGlobalService getData";
+const METHOD_NAME_GET_CODE = "optimizerGlobalService getCode";
+const METHOD_NAME_DUMP = "optimizerGlobalService dump";
+/**
+ * Global service for optimizer operations with validation.
+ * Entry point for public API, performs validation before delegating to ConnectionService.
+ *
+ * Workflow:
+ * 1. Log operation
+ * 2. Validate optimizer exists
+ * 3. Delegate to OptimizerConnectionService
+ */
+class OptimizerGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.optimizerConnectionService = inject(TYPES.optimizerConnectionService);
+        this.optimizerValidationService = inject(TYPES.optimizerValidationService);
+        /**
+         * Fetches data from all sources and generates strategy metadata.
+         * Validates optimizer existence before execution.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Array of generated strategies with conversation context
+         * @throws Error if optimizer not found
+         */
+        this.getData = async (symbol, optimizerName) => {
+            this.loggerService.log(METHOD_NAME_GET_DATA, {
+                symbol,
+                optimizerName,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_DATA);
+            return await this.optimizerConnectionService.getData(symbol, optimizerName);
+        };
+        /**
+         * Generates complete executable strategy code.
+         * Validates optimizer existence before execution.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Generated TypeScript/JavaScript code as string
+         * @throws Error if optimizer not found
+         */
+        this.getCode = async (symbol, optimizerName) => {
+            this.loggerService.log(METHOD_NAME_GET_CODE, {
+                symbol,
+                optimizerName,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_CODE);
+            return await this.optimizerConnectionService.getCode(symbol, optimizerName);
+        };
+        /**
+         * Generates and saves strategy code to file.
+         * Validates optimizer existence before execution.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @param path - Output directory path (optional)
+         * @throws Error if optimizer not found
+         */
+        this.dump = async (symbol, optimizerName, path) => {
+            this.loggerService.log(METHOD_NAME_DUMP, {
+                symbol,
+                optimizerName,
+                path,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_DUMP);
+            return await this.optimizerConnectionService.dump(symbol, optimizerName, path);
+        };
+    }
+}
+
+const ITERATION_LIMIT = 25;
+const DEFAULT_SOURCE_NAME = "unknown";
+const CREATE_PREFIX_FN = () => (Math.random() + 1).toString(36).substring(7);
+/**
+ * Default user message formatter.
+ * Delegates to template's getUserMessage method.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Fetched data array
+ * @param name - Source name
+ * @param self - ClientOptimizer instance
+ * @returns Formatted user message content
+ */
+const DEFAULT_USER_FN = async (symbol, data, name, self) => {
+    return await self.params.template.getUserMessage(symbol, data, name);
+};
+/**
+ * Default assistant message formatter.
+ * Delegates to template's getAssistantMessage method.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Fetched data array
+ * @param name - Source name
+ * @param self - ClientOptimizer instance
+ * @returns Formatted assistant message content
+ */
+const DEFAULT_ASSISTANT_FN = async (symbol, data, name, self) => {
+    return await self.params.template.getAssistantMessage(symbol, data, name);
+};
+/**
+ * Resolves paginated data from source with deduplication.
+ * Uses iterateDocuments to handle pagination automatically.
+ *
+ * @param fetch - Source fetch function
+ * @param filterData - Filter arguments (symbol, dates)
+ * @returns Deduplicated array of all fetched data
+ */
+const RESOLVE_PAGINATION_FN = async (fetch, filterData) => {
+    const iterator = iterateDocuments({
+        limit: ITERATION_LIMIT,
+        async createRequest({ limit, offset }) {
+            return await fetch({
+                symbol: filterData.symbol,
+                startDate: filterData.startDate,
+                endDate: filterData.endDate,
+                limit,
+                offset,
+            });
+        },
+    });
+    const distinct = distinctDocuments(iterator, (data) => data.id);
+    return await resolveDocuments(distinct);
+};
+/**
+ * Collects data from all sources and generates strategy metadata.
+ * Iterates through training ranges, fetches data from each source,
+ * builds LLM conversation history, and generates strategy prompts.
+ *
+ * @param symbol - Trading pair symbol
+ * @param self - ClientOptimizer instance
+ * @returns Array of generated strategies with conversation context
+ */
+const GET_STRATEGY_DATA_FN = async (symbol, self) => {
+    const strategyList = [];
+    for (const { startDate, endDate } of self.params.rangeTrain) {
+        const messageList = [];
+        for (const source of self.params.source) {
+            if (typeof source === "function") {
+                const data = await RESOLVE_PAGINATION_FN(source, {
+                    symbol,
+                    startDate,
+                    endDate,
+                });
+                if (self.params.callbacks?.onSourceData) {
+                    await self.params.callbacks.onSourceData(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,
+                });
+            }
+            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,
+                });
+                if (self.params.callbacks?.onSourceData) {
+                    await self.params.callbacks.onSourceData(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,
+                });
+            }
+            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),
+            });
+        }
+    }
+    if (self.params.callbacks?.onData) {
+        await self.params.callbacks.onData(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, `${prefix}_${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");
+    if (self.params.callbacks?.onCode) {
+        await self.params.callbacks.onCode(symbol, code);
+    }
+    return code;
+};
+/**
+ * Saves generated strategy code to file.
+ * Creates directory if needed, writes .mjs file with generated code.
+ *
+ * @param symbol - Trading pair symbol
+ * @param path - Output directory path
+ * @param self - ClientOptimizer instance
+ */
+const GET_STRATEGY_DUMP_FN = async (symbol, path, self) => {
+    const report = await self.getCode(symbol);
+    try {
+        const dir = join(process.cwd(), path);
+        await mkdir(dir, { recursive: true });
+        const filename = `${self.params.optimizerName}_${symbol}.mjs`;
+        const filepath = join(dir, filename);
+        await writeFile(filepath, report, "utf-8");
+        self.params.logger.info(`Optimizer report saved: ${filepath}`);
+        if (self.params.callbacks?.onDump) {
+            await self.params.callbacks.onDump(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) {
+        this.params = params;
+        /**
+         * 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);
+        };
+    }
+}
+
+/**
+ * Service for creating and caching optimizer client instances.
+ * Handles dependency injection and template merging.
+ *
+ * Features:
+ * - Memoized optimizer instances (one per optimizerName)
+ * - Template merging (custom + defaults)
+ * - Logger injection
+ * - Delegates to ClientOptimizer for actual operations
+ */
+class OptimizerConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.optimizerSchemaService = inject(TYPES.optimizerSchemaService);
+        this.optimizerTemplateService = inject(TYPES.optimizerTemplateService);
+        /**
+         * Creates or retrieves cached optimizer instance.
+         * Memoized by optimizerName for performance.
+         *
+         * Merges custom templates from schema with defaults from OptimizerTemplateService.
+         *
+         * @param optimizerName - Unique optimizer identifier
+         * @returns ClientOptimizer instance with resolved dependencies
+         */
+        this.getOptimizer = memoize(([optimizerName]) => `${optimizerName}`, (optimizerName) => {
+            const { getPrompt, rangeTest, rangeTrain, source, template: rawTemplate = {}, callbacks } = this.optimizerSchemaService.get(optimizerName);
+            const { getAssistantMessage = this.optimizerTemplateService.getAssistantMessage, getExchangeTemplate = this.optimizerTemplateService.getExchangeTemplate, getFrameTemplate = this.optimizerTemplateService.getFrameTemplate, getJsonDumpTemplate = this.optimizerTemplateService.getJsonDumpTemplate, getJsonTemplate = this.optimizerTemplateService.getJsonTemplate, getLauncherTemplate = this.optimizerTemplateService.getLauncherTemplate, getStrategyTemplate = this.optimizerTemplateService.getStrategyTemplate, getTextTemplate = this.optimizerTemplateService.getTextTemplate, getWalkerTemplate = this.optimizerTemplateService.getWalkerTemplate, getTopBanner = this.optimizerTemplateService.getTopBanner, getUserMessage = this.optimizerTemplateService.getUserMessage, } = rawTemplate;
+            const template = {
+                getAssistantMessage,
+                getExchangeTemplate,
+                getFrameTemplate,
+                getJsonDumpTemplate,
+                getJsonTemplate,
+                getLauncherTemplate,
+                getStrategyTemplate,
+                getTextTemplate,
+                getWalkerTemplate,
+                getTopBanner,
+                getUserMessage,
+            };
+            return new ClientOptimizer({
+                optimizerName,
+                logger: this.loggerService,
+                getPrompt,
+                rangeTest,
+                rangeTrain,
+                source,
+                template,
+                callbacks,
+            });
+        });
+        /**
+         * 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 = 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) {
+        throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+    }
+    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, currentPrice, level, backtest, when.getTime());
+        }
+    }
+    if (shouldPersist) {
+        await self._persistState(symbol);
+    }
+};
+/**
+ * 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) {
+        throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+    }
+    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, currentPrice, level, backtest, when.getTime());
+        }
+    }
+    if (shouldPersist) {
+        await self._persistState(symbol);
+    }
+};
+/**
+ * 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.
+ *
+ * @param symbol - Trading pair symbol
+ * @param self - ClientPartial instance reference
+ */
+const WAIT_FOR_INIT_FN = async (symbol, self) => {
+    self.params.logger.debug("ClientPartial waitForInit", { symbol });
+    if (self._states === NEED_FETCH) {
+        throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+    }
+    const partialData = await PersistPartialAdapter.readPartialData(symbol);
+    for (const [signalId, data] of Object.entries(partialData)) {
+        const state = {
+            profitLevels: new Set(data.profitLevels),
+            lossLevels: new Set(data.lossLevels),
+        };
+        self._states.set(signalId, state);
+    }
+    self.params.logger.info("ClientPartial restored state", {
+        symbol,
+        signalCount: Object.keys(partialData).length,
+    });
+};
+/**
+ * Client implementation for partial profit/loss level tracking.
+ *
+ * Features:
+ * - Tracks profit and loss level milestones (10%, 20%, 30%, etc) per signal
+ * - Deduplicates events using Set-based state per signal ID
+ * - Persists state to disk for crash recovery in live mode
+ * - Emits events via onProfit/onLoss callbacks for each newly reached level
+ *
+ * Architecture:
+ * - Created per signal ID by PartialConnectionService (memoized)
+ * - State stored in Map<signalId, IPartialState> with Set<PartialLevel>
+ * - Persistence handled by PersistPartialAdapter (atomic file writes)
+ *
+ * Lifecycle:
+ * 1. Construction: Initialize empty Map
+ * 2. waitForInit(): Load persisted state from disk
+ * 3. profit()/loss(): Check levels, emit events, persist changes
+ * 4. clear(): Remove signal state, persist, clean up memoized instance
+ *
+ * @example
+ * ```typescript
+ * import { ClientPartial } from "./client/ClientPartial";
+ *
+ * const partial = new ClientPartial({
+ *   logger: loggerService,
+ *   onProfit: async (symbol, data, price, level, backtest, timestamp) => {
+ *     console.log(`Signal ${data.id} reached ${level}% profit at ${price}`);
+ *     // Emit to partialProfitSubject
+ *   },
+ *   onLoss: async (symbol, data, price, level, backtest, timestamp) => {
+ *     console.log(`Signal ${data.id} reached -${level}% loss at ${price}`);
+ *     // Emit to partialLossSubject
+ *   }
+ * });
+ *
+ * // Initialize from persisted state
+ * await partial.waitForInit("BTCUSDT");
+ *
+ * // During signal monitoring in ClientStrategy
+ * const signal = { id: "abc123", priceOpen: 50000, position: "long", ... };
+ *
+ * // Price rises to $55000 (10% profit)
+ * await partial.profit("BTCUSDT", signal, 55000, 10.0, false, new Date());
+ * // Emits onProfit callback for 10% level
+ *
+ * // Price rises to $61000 (22% profit)
+ * await partial.profit("BTCUSDT", signal, 61000, 22.0, false, new Date());
+ * // Emits onProfit for 20% level only (10% already emitted)
+ *
+ * // Signal closes
+ * await partial.clear("BTCUSDT", signal, 61000);
+ * // State removed, changes persisted
+ * ```
+ */
+class ClientPartial {
+    /**
+     * Creates new ClientPartial instance.
+     *
+     * @param params - Partial parameters (logger, onProfit, onLoss callbacks)
+     */
+    constructor(params) {
+        this.params = params;
+        /**
+         * Map of signal IDs to partial profit/loss state.
+         * Uses NEED_FETCH sentinel before initialization.
+         *
+         * Each state contains:
+         * - profitLevels: Set of reached profit levels (10, 20, 30, etc)
+         * - lossLevels: Set of reached loss levels (10, 20, 30, etc)
+         */
+        this._states = NEED_FETCH;
+        /**
+         * Initializes partial state by loading from disk.
+         *
+         * Uses singleshot pattern to ensure initialization happens exactly once per symbol.
+         * Reads persisted state from PersistPartialAdapter and restores to _states Map.
+         *
+         * Must be called before profit()/loss()/clear() methods.
+         *
+         * @param symbol - Trading pair symbol
+         * @returns Promise that resolves when initialization is complete
+         *
+         * @example
+         * ```typescript
+         * const partial = new ClientPartial(params);
+         * await partial.waitForInit("BTCUSDT"); // Load persisted state
+         * // Now profit()/loss() can be called
+         * ```
+         */
+        this.waitForInit = singleshot(async (symbol) => await WAIT_FOR_INIT_FN(symbol, this));
+        this._states = new Map();
+    }
+    /**
+     * Persists current partial state to disk.
+     *
+     * Converts in-memory Maps and Sets to JSON-serializable format:
+     * - Map<signalId, IPartialState> → Record<signalId, IPartialData>
+     * - Set<PartialLevel> → PartialLevel[]
+     *
+     * Called automatically after profit/loss level changes or clear().
+     * Uses atomic file writes via PersistPartialAdapter.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise that resolves when persistence is complete
+     */
+    async _persistState(symbol) {
+        this.params.logger.debug("ClientPartial persistState", { symbol });
+        if (this._states === NEED_FETCH) {
+            throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+        }
+        const partialData = {};
+        for (const [signalId, state] of this._states.entries()) {
+            partialData[signalId] = {
+                profitLevels: Array.from(state.profitLevels),
+                lossLevels: Array.from(state.lossLevels),
+            };
+        }
+        await PersistPartialAdapter.writePartialData(partialData, symbol);
+    }
+    /**
+     * Processes profit state and emits events for newly reached profit levels.
+     *
+     * Called by ClientStrategy during signal monitoring when revenuePercent > 0.
+     * Iterates through PROFIT_LEVELS (10%, 20%, 30%, etc) and checks which
+     * levels have been reached but not yet emitted (Set-based deduplication).
+     *
+     * For each new level:
+     * 1. Adds level to state.profitLevels Set
+     * 2. Logs debug message
+     * 3. Calls params.onProfit callback (emits to partialProfitSubject)
+     *
+     * After all levels processed, persists state to disk if any new levels were found.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param revenuePercent - Current profit percentage (positive value)
+     * @param backtest - True if backtest mode, false if live mode
+     * @param when - Event timestamp (current time for live, candle time for backtest)
+     * @returns Promise that resolves when profit processing is complete
+     *
+     * @example
+     * ```typescript
+     * // Signal at $50000, price rises to $61000 (22% profit)
+     * await partial.profit("BTCUSDT", signal, 61000, 22.0, false, new Date());
+     * // Emits events for 10% and 20% levels (if not already emitted)
+     * // State persisted to disk
+     * ```
+     */
+    async profit(symbol, data, currentPrice, revenuePercent, backtest, when) {
+        this.params.logger.debug("ClientPartial profit", {
+            symbol,
+            signalId: data.id,
+            currentPrice,
+            revenuePercent,
+            backtest,
+            when,
+        });
+        return await HANDLE_PROFIT_FN(symbol, data, currentPrice, revenuePercent, backtest, when, this);
+    }
+    /**
+     * Processes loss state and emits events for newly reached loss levels.
+     *
+     * Called by ClientStrategy during signal monitoring when revenuePercent < 0.
+     * Converts negative lossPercent to absolute value and iterates through
+     * LOSS_LEVELS (10%, 20%, 30%, etc) to check which levels have been reached
+     * but not yet emitted (Set-based deduplication).
+     *
+     * For each new level:
+     * 1. Adds level to state.lossLevels Set
+     * 2. Logs debug message
+     * 3. Calls params.onLoss callback (emits to partialLossSubject)
+     *
+     * After all levels processed, persists state to disk if any new levels were found.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param lossPercent - Current loss percentage (negative value)
+     * @param backtest - True if backtest mode, false if live mode
+     * @param when - Event timestamp (current time for live, candle time for backtest)
+     * @returns Promise that resolves when loss processing is complete
+     *
+     * @example
+     * ```typescript
+     * // Signal at $50000, price drops to $39000 (-22% loss)
+     * await partial.loss("BTCUSDT", signal, 39000, -22.0, false, new Date());
+     * // Emits events for 10% and 20% loss levels (if not already emitted)
+     * // State persisted to disk
+     * ```
+     */
+    async loss(symbol, data, currentPrice, lossPercent, backtest, when) {
+        this.params.logger.debug("ClientPartial loss", {
+            symbol,
+            signalId: data.id,
+            currentPrice,
+            lossPercent,
+            backtest,
+            when,
+        });
+        return await HANDLE_LOSS_FN(symbol, data, currentPrice, lossPercent, backtest, when, this);
+    }
+    /**
+     * Clears partial profit/loss state for a signal when it closes.
+     *
+     * Called by ClientStrategy when signal completes (TP/SL/time_expired).
+     * Removes signal's state from _states Map and persists changes to disk.
+     *
+     * After clear() completes:
+     * - Signal state removed from memory (_states.delete)
+     * - Changes persisted to disk (PersistPartialAdapter.writePartialData)
+     * - Memoized ClientPartial instance cleared in PartialConnectionService
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param priceClose - Final closing price
+     * @returns Promise that resolves when clear is complete
+     * @throws Error if ClientPartial not initialized (waitForInit not called)
+     *
+     * @example
+     * ```typescript
+     * // Signal closes at take profit
+     * await partial.clear("BTCUSDT", signal, 52000);
+     * // State removed: _states.delete(signal.id)
+     * // Persisted: ./dump/data/partial/BTCUSDT/levels.json updated
+     * // Cleanup: PartialConnectionService.getPartial.clear(signal.id)
+     * ```
+     */
+    async clear(symbol, data, priceClose) {
+        this.params.logger.log("ClientPartial clear", {
+            symbol,
+            data,
+            priceClose,
+        });
+        if (this._states === NEED_FETCH) {
+            throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+        }
+        this._states.delete(data.id);
+        await this._persistState(symbol);
+    }
+}
+
+/**
+ * Callback function for emitting profit events to partialProfitSubject.
+ *
+ * Called by ClientPartial when a new profit level is reached.
+ * Emits PartialProfitContract event to all subscribers.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Signal row data
+ * @param currentPrice - Current market price
+ * @param level - Profit level reached
+ * @param backtest - True if backtest mode
+ * @param timestamp - Event timestamp in milliseconds
+ */
+const COMMIT_PROFIT_FN = async (symbol, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
+    symbol,
+    data,
+    currentPrice,
+    level,
+    backtest,
+    timestamp,
+});
+/**
+ * Callback function for emitting loss events to partialLossSubject.
+ *
+ * Called by ClientPartial when a new loss level is reached.
+ * Emits PartialLossContract event to all subscribers.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Signal row data
+ * @param currentPrice - Current market price
+ * @param level - Loss level reached
+ * @param backtest - True if backtest mode
+ * @param timestamp - Event timestamp in milliseconds
+ */
+const COMMIT_LOSS_FN = async (symbol, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
+    symbol,
+    data,
+    currentPrice,
+    level,
+    backtest,
+    timestamp,
+});
+/**
+ * Connection service for partial profit/loss tracking.
+ *
+ * Provides memoized ClientPartial instances per signal ID.
+ * Acts as factory and lifetime manager for ClientPartial objects.
+ *
+ * Features:
+ * - Creates one ClientPartial instance per signal ID (memoized)
+ * - Configures instances with logger and event emitter callbacks
+ * - Delegates profit/loss/clear operations to appropriate ClientPartial
+ * - Cleans up memoized instances when signals are cleared
+ *
+ * Architecture:
+ * - Injected into ClientStrategy via PartialGlobalService
+ * - Uses memoize from functools-kit for instance caching
+ * - Emits events to partialProfitSubject/partialLossSubject
+ *
+ * @example
+ * ```typescript
+ * // Service injected via DI
+ * const service = inject<PartialConnectionService>(TYPES.partialConnectionService);
+ *
+ * // Called by ClientStrategy during signal monitoring
+ * await service.profit("BTCUSDT", signal, 55000, 10.0, false, new Date());
+ * // Creates or reuses ClientPartial for signal.id
+ * // Delegates to ClientPartial.profit()
+ *
+ * // When signal closes
+ * await service.clear("BTCUSDT", signal, 52000);
+ * // Clears signal state and removes memoized instance
+ * ```
+ */
+class PartialConnectionService {
+    constructor() {
+        /**
+         * Logger service injected from DI container.
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized factory function for ClientPartial instances.
+         *
+         * Creates one ClientPartial per signal ID with configured callbacks.
+         * Instances are cached until clear() is called.
+         *
+         * Key format: signalId
+         * Value: ClientPartial instance with logger and event emitters
+         */
+        this.getPartial = memoize(([signalId]) => `${signalId}`, () => {
+            return new ClientPartial({
+                logger: this.loggerService,
+                onProfit: COMMIT_PROFIT_FN,
+                onLoss: COMMIT_LOSS_FN,
+            });
+        });
+        /**
+         * Processes profit state and emits events for newly reached profit levels.
+         *
+         * Retrieves or creates ClientPartial for signal ID, initializes it if needed,
+         * then delegates to ClientPartial.profit() method.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param data - Signal row data
+         * @param currentPrice - Current market price
+         * @param revenuePercent - Current profit percentage (positive value)
+         * @param backtest - True if backtest mode, false if live mode
+         * @param when - Event timestamp (current time for live, candle time for backtest)
+         * @returns Promise that resolves when profit processing is complete
+         */
+        this.profit = async (symbol, data, currentPrice, revenuePercent, backtest, when) => {
+            this.loggerService.log("partialConnectionService profit", {
+                symbol,
+                data,
+                currentPrice,
+                revenuePercent,
+                backtest,
+                when,
+            });
+            const partial = this.getPartial(data.id);
+            await partial.waitForInit(symbol);
+            return await partial.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
+        };
+        /**
+         * Processes loss state and emits events for newly reached loss levels.
+         *
+         * Retrieves or creates ClientPartial for signal ID, initializes it if needed,
+         * then delegates to ClientPartial.loss() method.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param data - Signal row data
+         * @param currentPrice - Current market price
+         * @param lossPercent - Current loss percentage (negative value)
+         * @param backtest - True if backtest mode, false if live mode
+         * @param when - Event timestamp (current time for live, candle time for backtest)
+         * @returns Promise that resolves when loss processing is complete
+         */
+        this.loss = async (symbol, data, currentPrice, lossPercent, backtest, when) => {
+            this.loggerService.log("partialConnectionService loss", {
+                symbol,
+                data,
+                currentPrice,
+                lossPercent,
+                backtest,
+                when,
+            });
+            const partial = this.getPartial(data.id);
+            await partial.waitForInit(symbol);
+            return await partial.loss(symbol, data, currentPrice, lossPercent, backtest, when);
+        };
+        /**
+         * Clears partial profit/loss state when signal closes.
+         *
+         * Retrieves ClientPartial for signal ID, initializes if needed,
+         * delegates clear operation, then removes memoized instance.
+         *
+         * Sequence:
+         * 1. Get ClientPartial from memoize cache
+         * 2. Ensure initialization (waitForInit)
+         * 3. Call ClientPartial.clear() - removes state, persists to disk
+         * 4. Clear memoized instance - prevents memory leaks
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param data - Signal row data
+         * @param priceClose - Final closing price
+         * @returns Promise that resolves when clear is complete
+         */
+        this.clear = async (symbol, data, priceClose) => {
+            this.loggerService.log("partialConnectionService profit", {
+                symbol,
+                data,
+                priceClose,
+            });
+            const partial = this.getPartial(data.id);
+            await partial.waitForInit(symbol);
+            await partial.clear(symbol, data, priceClose);
+            this.getPartial.clear(data.id);
+        };
+    }
+}
+
+const columns = [
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+    },
+    {
+        key: "level",
+        label: "Level %",
+        format: (data) => data.action === "profit" ? `+${data.level}%` : `-${data.level}%`,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+    },
+    {
+        key: "mode",
+        label: "Mode",
+        format: (data) => (data.backtest ? "Backtest" : "Live"),
+    },
+];
+/** Maximum number of events to store in partial reports */
+const MAX_EVENTS = 250;
+/**
+ * Storage class for accumulating partial profit/loss events per symbol.
+ * Maintains a chronological list of profit and loss level events.
+ */
+class ReportStorage {
+    constructor() {
+        /** Internal list of all partial events for this symbol */
+        this._eventList = [];
+    }
+    /**
+     * Adds a profit event to the storage.
+     *
+     * @param symbol - Trading pair symbol
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param level - Profit level reached
+     * @param backtest - True if backtest mode
+     */
+    addProfitEvent(symbol, data, currentPrice, level, backtest, timestamp) {
+        this._eventList.push({
+            timestamp,
+            action: "profit",
+            symbol,
+            signalId: data.id,
+            position: data.position,
+            currentPrice,
+            level,
+            backtest,
+        });
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS) {
+            this._eventList.shift();
+        }
+    }
+    /**
+     * Adds a loss event to the storage.
+     *
+     * @param symbol - Trading pair symbol
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param level - Loss level reached
+     * @param backtest - True if backtest mode
+     */
+    addLossEvent(symbol, data, currentPrice, level, backtest, timestamp) {
+        this._eventList.push({
+            timestamp,
+            action: "loss",
+            symbol,
+            signalId: data.id,
+            position: data.position,
+            currentPrice,
+            level,
+            backtest,
+        });
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS) {
+            this._eventList.shift();
+        }
+    }
+    /**
+     * Calculates statistical data from partial profit/loss events (Controller).
+     *
+     * @returns Statistical data (empty object if no events)
+     */
+    async getData() {
+        if (this._eventList.length === 0) {
+            return {
+                eventList: [],
+                totalEvents: 0,
+                totalProfit: 0,
+                totalLoss: 0,
+            };
+        }
+        const profitEvents = this._eventList.filter((e) => e.action === "profit");
+        const lossEvents = this._eventList.filter((e) => e.action === "loss");
+        return {
+            eventList: this._eventList,
+            totalEvents: this._eventList.length,
+            totalProfit: profitEvents.length,
+            totalLoss: lossEvents.length,
+        };
+    }
+    /**
+     * Generates markdown report with all partial events for a symbol (View).
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Markdown formatted report with all events
+     */
+    async getReport(symbol) {
+        const stats = await this.getData();
+        if (stats.totalEvents === 0) {
+            return str.newline(`# Partial Profit/Loss Report: ${symbol}`, "", "No partial profit/loss events recorded yet.");
+        }
+        const header = columns.map((col) => col.label);
+        const separator = columns.map(() => "---");
+        const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
+        const tableData = [header, separator, ...rows];
+        const table = str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
+        return str.newline(`# Partial Profit/Loss Report: ${symbol}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Profit events:** ${stats.totalProfit}`, `**Loss events:** ${stats.totalLoss}`);
+    }
+    /**
+     * Saves symbol report to disk.
+     *
+     * @param symbol - Trading pair symbol
+     * @param path - Directory path to save report (default: "./dump/partial")
+     */
+    async dump(symbol, path = "./dump/partial") {
+        const markdown = await this.getReport(symbol);
+        try {
+            const dir = join(process.cwd(), path);
+            await mkdir(dir, { recursive: true });
+            const filename = `${symbol}.md`;
+            const filepath = join(dir, filename);
+            await writeFile(filepath, markdown, "utf-8");
+            console.log(`Partial profit/loss report saved: ${filepath}`);
+        }
+        catch (error) {
+            console.error(`Failed to save markdown report:`, error);
+        }
+    }
+}
+/**
+ * Service for generating and saving partial profit/loss markdown reports.
+ *
+ * Features:
+ * - Listens to partial profit and loss events via partialProfitSubject/partialLossSubject
+ * - Accumulates all events (profit, loss) per symbol
+ * - Generates markdown tables with detailed event information
+ * - Provides statistics (total profit/loss events)
+ * - Saves reports to disk in dump/partial/{symbol}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new PartialMarkdownService();
+ *
+ * // Service automatically subscribes to subjects on init
+ * // No manual callback setup needed
+ *
+ * // Later: generate and save report
+ * await service.dump("BTCUSDT");
+ * ```
+ */
+class PartialMarkdownService {
+    constructor() {
+        /** Logger service for debug output */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized function to get or create ReportStorage for a symbol.
+         * Each symbol gets its own isolated storage instance.
+         */
+        this.getStorage = memoize(([symbol]) => `${symbol}`, () => new ReportStorage());
+        /**
+         * Processes profit events and accumulates them.
+         * Should be called from partialProfitSubject subscription.
+         *
+         * @param data - Profit event data
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * // Service automatically subscribes in init()
+         * ```
+         */
+        this.tickProfit = async (data) => {
+            this.loggerService.log("partialMarkdownService tickProfit", {
+                data,
+            });
+            const storage = this.getStorage(data.symbol);
+            storage.addProfitEvent(data.symbol, data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
+        };
+        /**
+         * Processes loss events and accumulates them.
+         * Should be called from partialLossSubject subscription.
+         *
+         * @param data - Loss event data
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * // Service automatically subscribes in init()
+         * ```
+         */
+        this.tickLoss = async (data) => {
+            this.loggerService.log("partialMarkdownService tickLoss", {
+                data,
+            });
+            const storage = this.getStorage(data.symbol);
+            storage.addLossEvent(data.symbol, data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
+        };
+        /**
+         * Gets statistical data from all partial profit/loss events for a symbol.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param symbol - Trading pair symbol to get data for
+         * @returns Statistical data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * const stats = await service.getData("BTCUSDT");
+         * console.log(stats.totalProfit, stats.totalLoss);
+         * ```
+         */
+        this.getData = async (symbol) => {
+            this.loggerService.log("partialMarkdownService getData", {
+                symbol,
+            });
+            const storage = this.getStorage(symbol);
+            return storage.getData();
+        };
+        /**
+         * Generates markdown report with all partial events for a symbol.
+         * Delegates to ReportStorage.getReport().
+         *
+         * @param symbol - Trading pair symbol to generate report for
+         * @returns Markdown formatted report string with table of all events
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * const markdown = await service.getReport("BTCUSDT");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol) => {
+            this.loggerService.log("partialMarkdownService getReport", {
+                symbol,
+            });
+            const storage = this.getStorage(symbol);
+            return storage.getReport(symbol);
+        };
+        /**
+         * Saves symbol report to disk.
+         * Creates directory if it doesn't exist.
+         * Delegates to ReportStorage.dump().
+         *
+         * @param symbol - Trading pair symbol to save report for
+         * @param path - Directory path to save report (default: "./dump/partial")
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         *
+         * // Save to default path: ./dump/partial/BTCUSDT.md
+         * await service.dump("BTCUSDT");
+         *
+         * // Save to custom path: ./custom/path/BTCUSDT.md
+         * await service.dump("BTCUSDT", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, path = "./dump/partial") => {
+            this.loggerService.log("partialMarkdownService dump", {
+                symbol,
+                path,
+            });
+            const storage = this.getStorage(symbol);
+            await storage.dump(symbol, path);
+        };
+        /**
+         * Clears accumulated event data from storage.
+         * If symbol is provided, clears only that symbol's data.
+         * If symbol is omitted, clears all symbols' data.
+         *
+         * @param symbol - Optional symbol to clear specific symbol data
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         *
+         * // Clear specific symbol data
+         * await service.clear("BTCUSDT");
+         *
+         * // Clear all symbols' data
+         * await service.clear();
+         * ```
+         */
+        this.clear = async (symbol) => {
+            this.loggerService.log("partialMarkdownService clear", {
+                symbol,
+            });
+            this.getStorage.clear(symbol);
+        };
+        /**
+         * Initializes the service by subscribing to partial profit/loss events.
+         * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * await service.init(); // Subscribe to profit/loss events
+         * ```
+         */
+        this.init = singleshot(async () => {
+            this.loggerService.log("partialMarkdownService init");
+            partialProfitSubject.subscribe(this.tickProfit);
+            partialLossSubject.subscribe(this.tickLoss);
+        });
+    }
+}
+
+/**
+ * Global service for partial profit/loss tracking.
+ *
+ * Thin delegation layer that forwards operations to PartialConnectionService.
+ * Provides centralized logging for all partial operations at the global level.
+ *
+ * Architecture:
+ * - Injected into ClientStrategy constructor via IStrategyParams
+ * - Delegates all operations to PartialConnectionService
+ * - Logs operations at "partialGlobalService" level before delegation
+ *
+ * Purpose:
+ * - Single injection point for ClientStrategy (dependency injection pattern)
+ * - Centralized logging for monitoring partial operations
+ * - Layer of abstraction between strategy and connection layer
+ *
+ * @example
+ * ```typescript
+ * // Service injected into ClientStrategy via DI
+ * const strategy = new ClientStrategy({
+ *   partial: partialGlobalService,
+ *   ...
+ * });
+ *
+ * // Called during signal monitoring
+ * await strategy.params.partial.profit("BTCUSDT", signal, 55000, 10.0, false, new Date());
+ * // Logs at global level → delegates to PartialConnectionService
+ * ```
+ */
+class PartialGlobalService {
+    constructor() {
+        /**
+         * Logger service injected from DI container.
+         * Used for logging operations at global service level.
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Connection service injected from DI container.
+         * Handles actual ClientPartial instance creation and management.
+         */
+        this.partialConnectionService = inject(TYPES.partialConnectionService);
+        /**
+         * Processes profit state and emits events for newly reached profit levels.
+         *
+         * Logs operation at global service level, then delegates to PartialConnectionService.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param data - Signal row data
+         * @param currentPrice - Current market price
+         * @param revenuePercent - Current profit percentage (positive value)
+         * @param backtest - True if backtest mode, false if live mode
+         * @param when - Event timestamp (current time for live, candle time for backtest)
+         * @returns Promise that resolves when profit processing is complete
+         */
+        this.profit = async (symbol, data, currentPrice, revenuePercent, backtest, when) => {
+            this.loggerService.log("partialGlobalService profit", {
+                symbol,
+                data,
+                currentPrice,
+                revenuePercent,
+                backtest,
+                when,
+            });
+            return await this.partialConnectionService.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
+        };
+        /**
+         * Processes loss state and emits events for newly reached loss levels.
+         *
+         * Logs operation at global service level, then delegates to PartialConnectionService.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param data - Signal row data
+         * @param currentPrice - Current market price
+         * @param lossPercent - Current loss percentage (negative value)
+         * @param backtest - True if backtest mode, false if live mode
+         * @param when - Event timestamp (current time for live, candle time for backtest)
+         * @returns Promise that resolves when loss processing is complete
+         */
+        this.loss = async (symbol, data, currentPrice, lossPercent, backtest, when) => {
+            this.loggerService.log("partialGlobalService loss", {
+                symbol,
+                data,
+                currentPrice,
+                lossPercent,
+                backtest,
+                when,
+            });
+            return await this.partialConnectionService.loss(symbol, data, currentPrice, lossPercent, backtest, when);
+        };
+        /**
+         * Clears partial profit/loss state when signal closes.
+         *
+         * Logs operation at global service level, then delegates to PartialConnectionService.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param data - Signal row data
+         * @param priceClose - Final closing price
+         * @returns Promise that resolves when clear is complete
+         */
+        this.clear = async (symbol, data, priceClose) => {
+            this.loggerService.log("partialGlobalService profit", {
+                symbol,
+                data,
+                priceClose,
+            });
+            return await this.partialConnectionService.clear(symbol, data, priceClose);
+        };
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+}
+{
+    provide(TYPES.executionContextService, () => new ExecutionContextService());
+    provide(TYPES.methodContextService, () => new MethodContextService());
+}
+{
+    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
+    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
+    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
+    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
+    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
+    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
+    provide(TYPES.partialConnectionService, () => new PartialConnectionService());
+}
+{
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
+    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
+    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
+    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
+    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
+    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
+    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
+}
+{
+    provide(TYPES.exchangeGlobalService, () => new ExchangeGlobalService());
     provide(TYPES.strategyGlobalService, () => new StrategyGlobalService());
     provide(TYPES.frameGlobalService, () => new FrameGlobalService());
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
     provide(TYPES.riskGlobalService, () => new RiskGlobalService());
+    provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
+    provide(TYPES.partialGlobalService, () => new PartialGlobalService());
 }
 {
     provide(TYPES.liveCommandService, () => new LiveCommandService());
@@ -7900,6 +10524,7 @@ class RiskValidationService {
     provide(TYPES.performanceMarkdownService, () => new PerformanceMarkdownService());
     provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
+    provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -7908,6 +10533,10 @@ class RiskValidationService {
     provide(TYPES.walkerValidationService, () => new WalkerValidationService());
     provide(TYPES.sizingValidationService, () => new SizingValidationService());
     provide(TYPES.riskValidationService, () => new RiskValidationService());
+    provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
+}
+{
+    provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
 }
 
 const baseServices = {
@@ -7923,6 +10552,8 @@ const connectionServices = {
     frameConnectionService: inject(TYPES.frameConnectionService),
     sizingConnectionService: inject(TYPES.sizingConnectionService),
     riskConnectionService: inject(TYPES.riskConnectionService),
+    optimizerConnectionService: inject(TYPES.optimizerConnectionService),
+    partialConnectionService: inject(TYPES.partialConnectionService),
 };
 const schemaServices = {
     exchangeSchemaService: inject(TYPES.exchangeSchemaService),
@@ -7931,6 +10562,7 @@ const schemaServices = {
     walkerSchemaService: inject(TYPES.walkerSchemaService),
     sizingSchemaService: inject(TYPES.sizingSchemaService),
     riskSchemaService: inject(TYPES.riskSchemaService),
+    optimizerSchemaService: inject(TYPES.optimizerSchemaService),
 };
 const globalServices = {
     exchangeGlobalService: inject(TYPES.exchangeGlobalService),
@@ -7938,6 +10570,8 @@ const globalServices = {
     frameGlobalService: inject(TYPES.frameGlobalService),
     sizingGlobalService: inject(TYPES.sizingGlobalService),
     riskGlobalService: inject(TYPES.riskGlobalService),
+    optimizerGlobalService: inject(TYPES.optimizerGlobalService),
+    partialGlobalService: inject(TYPES.partialGlobalService),
 };
 const commandServices = {
     liveCommandService: inject(TYPES.liveCommandService),
@@ -7961,6 +10595,7 @@ const markdownServices = {
     performanceMarkdownService: inject(TYPES.performanceMarkdownService),
     walkerMarkdownService: inject(TYPES.walkerMarkdownService),
     heatMarkdownService: inject(TYPES.heatMarkdownService),
+    partialMarkdownService: inject(TYPES.partialMarkdownService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -7969,6 +10604,10 @@ const validationServices = {
     walkerValidationService: inject(TYPES.walkerValidationService),
     sizingValidationService: inject(TYPES.sizingValidationService),
     riskValidationService: inject(TYPES.riskValidationService),
+    optimizerValidationService: inject(TYPES.optimizerValidationService),
+};
+const templateServices = {
+    optimizerTemplateService: inject(TYPES.optimizerTemplateService),
 };
 const backtest = {
     ...baseServices,
@@ -7981,6 +10620,7 @@ const backtest = {
     ...logicPublicServices,
     ...markdownServices,
     ...validationServices,
+    ...templateServices,
 };
 init();
 var backtest$1 = backtest;
@@ -8026,6 +10666,7 @@ const ADD_FRAME_METHOD_NAME = "add.addFrame";
 const ADD_WALKER_METHOD_NAME = "add.addWalker";
 const ADD_SIZING_METHOD_NAME = "add.addSizing";
 const ADD_RISK_METHOD_NAME = "add.addRisk";
+const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizer";
 /**
  * Registers a trading strategy in the framework.
  *
@@ -8317,6 +10958,100 @@ function addRisk(riskSchema) {
     backtest$1.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
     backtest$1.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 addOptimizer(optimizerSchema) {
+    backtest$1.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
+        optimizerSchema,
+    });
+    backtest$1.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
+    backtest$1.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
+}
 
 const LIST_EXCHANGES_METHOD_NAME = "list.listExchanges";
 const LIST_STRATEGIES_METHOD_NAME = "list.listStrategies";
@@ -8324,6 +11059,7 @@ const LIST_FRAMES_METHOD_NAME = "list.listFrames";
 const LIST_WALKERS_METHOD_NAME = "list.listWalkers";
 const LIST_SIZINGS_METHOD_NAME = "list.listSizings";
 const LIST_RISKS_METHOD_NAME = "list.listRisks";
+const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizers";
 /**
  * Returns a list of all registered exchange schemas.
  *
@@ -8521,6 +11257,46 @@ async function listRisks() {
     backtest$1.loggerService.log(LIST_RISKS_METHOD_NAME);
     return await backtest$1.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 listOptimizers() {
+    backtest$1.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
+    return await backtest$1.optimizerValidationService.list();
+}
 
 const LISTEN_SIGNAL_METHOD_NAME = "event.listenSignal";
 const LISTEN_SIGNAL_ONCE_METHOD_NAME = "event.listenSignalOnce";
@@ -8535,12 +11311,17 @@ const LISTEN_DONE_BACKTEST_METHOD_NAME = "event.listenDoneBacktest";
 const LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME = "event.listenDoneBacktestOnce";
 const LISTEN_DONE_WALKER_METHOD_NAME = "event.listenDoneWalker";
 const LISTEN_DONE_WALKER_ONCE_METHOD_NAME = "event.listenDoneWalkerOnce";
-const LISTEN_PROGRESS_METHOD_NAME = "event.listenProgress";
+const LISTEN_PROGRESS_METHOD_NAME = "event.listenBacktestProgress";
+const LISTEN_PROGRESS_WALKER_METHOD_NAME = "event.listenWalkerProgress";
 const LISTEN_PERFORMANCE_METHOD_NAME = "event.listenPerformance";
 const LISTEN_WALKER_METHOD_NAME = "event.listenWalker";
 const LISTEN_WALKER_ONCE_METHOD_NAME = "event.listenWalkerOnce";
 const LISTEN_WALKER_COMPLETE_METHOD_NAME = "event.listenWalkerComplete";
 const LISTEN_VALIDATION_METHOD_NAME = "event.listenValidation";
+const LISTEN_PARTIAL_PROFIT_METHOD_NAME = "event.listenPartialProfit";
+const LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME = "event.listenPartialProfitOnce";
+const LISTEN_PARTIAL_LOSS_METHOD_NAME = "event.listenPartialLoss";
+const LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME = "event.listenPartialLossOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -8921,21 +11702,55 @@ function listenDoneWalkerOnce(filterFn, fn) {
  * 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 progress events
+ * @param fn - Callback function to handle progress events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenBacktestProgress, Backtest } from "backtest-kit";
+ *
+ * const unsubscribe = listenBacktestProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`${event.processedFrames} / ${event.totalFrames} frames`);
+ *   console.log(`Strategy: ${event.strategyName}, Symbol: ${event.symbol}`);
+ * });
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenBacktestProgress(fn) {
+    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
+    return progressBacktestEmitter.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to walker progress events with queued async processing.
+ *
+ * Emits during Walker.run() execution after each strategy completes.
+ * 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 walker progress events
  * @returns Unsubscribe function to stop listening to events
  *
  * @example
  * ```typescript
- * import { listenProgress, Backtest } from "backtest-kit";
+ * import { listenWalkerProgress, Walker } from "backtest-kit";
  *
- * const unsubscribe = listenProgress((event) => {
+ * const unsubscribe = listenWalkerProgress((event) => {
  *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
- *   console.log(`${event.processedFrames} / ${event.totalFrames} frames`);
- *   console.log(`Strategy: ${event.strategyName}, Symbol: ${event.symbol}`);
+ *   console.log(`${event.processedStrategies} / ${event.totalStrategies} strategies`);
+ *   console.log(`Walker: ${event.walkerName}, Symbol: ${event.symbol}`);
  * });
  *
- * Backtest.background("BTCUSDT", {
- *   strategyName: "my-strategy",
+ * Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker",
  *   exchangeName: "binance",
  *   frameName: "1d-backtest"
  * });
@@ -8944,9 +11759,9 @@ function listenDoneWalkerOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
-    return progressEmitter.subscribe(queued(async (event) => fn(event)));
+function listenWalkerProgress(fn) {
+    backtest$1.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
+    return progressWalkerEmitter.subscribe(queued(async (event) => fn(event)));
 }
 /**
  * Subscribes to performance metric events with queued async processing.
@@ -9124,6 +11939,130 @@ function listenValidation(fn) {
     backtest$1.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
     return validationSubject.subscribe(queued(async (error) => fn(error)));
 }
+/**
+ * Subscribes to partial profit level events with queued async processing.
+ *
+ * Emits when a signal reaches a profit level milestone (10%, 20%, 30%, etc).
+ * 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 partial profit events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenPartialProfit } from "./function/event";
+ *
+ * const unsubscribe = listenPartialProfit((event) => {
+ *   console.log(`Signal ${event.data.id} reached ${event.level}% profit`);
+ *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
+ *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenPartialProfit(fn) {
+    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
+    return partialProfitSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered partial profit level events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific profit conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenPartialProfitOnce } from "./function/event";
+ *
+ * // Wait for first 50% profit level on any signal
+ * listenPartialProfitOnce(
+ *   (event) => event.level === 50,
+ *   (event) => console.log("50% profit reached:", event.data.id)
+ * );
+ *
+ * // Wait for 30% profit on BTCUSDT
+ * const cancel = listenPartialProfitOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.level === 30,
+ *   (event) => console.log("BTCUSDT hit 30% profit")
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+function listenPartialProfitOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME);
+    return partialProfitSubject.filter(filterFn).once(fn);
+}
+/**
+ * Subscribes to partial loss level events with queued async processing.
+ *
+ * Emits when a signal reaches a loss level milestone (10%, 20%, 30%, etc).
+ * 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 partial loss events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenPartialLoss } from "./function/event";
+ *
+ * const unsubscribe = listenPartialLoss((event) => {
+ *   console.log(`Signal ${event.data.id} reached ${event.level}% loss`);
+ *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
+ *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenPartialLoss(fn) {
+    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
+    return partialLossSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered partial loss level events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific loss conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenPartialLossOnce } from "./function/event";
+ *
+ * // Wait for first 20% loss level on any signal
+ * listenPartialLossOnce(
+ *   (event) => event.level === 20,
+ *   (event) => console.log("20% loss reached:", event.data.id)
+ * );
+ *
+ * // Wait for 10% loss on ETHUSDT in live mode
+ * const cancel = listenPartialLossOnce(
+ *   (event) => event.symbol === "ETHUSDT" && event.level === 10 && !event.backtest,
+ *   (event) => console.log("ETHUSDT hit 10% loss in live mode")
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+function listenPartialLossOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
+    return partialLossSubject.filter(filterFn).once(fn);
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -9341,22 +12280,42 @@ class BacktestUtils {
                 context,
             });
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const _ of this.run(symbol, context)) {
                     if (isStopped) {
                         break;
                     }
                 }
-                await doneBacktestSubject.next({
-                    exchangeName: context.exchangeName,
-                    strategyName: context.strategyName,
-                    backtest: true,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneBacktestSubject.next({
+                        exchangeName: context.exchangeName,
+                        strategyName: context.strategyName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
+                    if (!isDone) {
+                        await doneBacktestSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: true,
+                            symbol,
+                        });
+                    }
+                    isDone = true;
+                });
                 isStopped = true;
             };
         };
@@ -9400,11 +12359,11 @@ class BacktestUtils {
          * Saves strategy report to disk.
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Optional directory path to save report (default: "./logs/backtest")
+         * @param path - Optional directory path to save report (default: "./dump/backtest")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/backtest/my-strategy.md
+         * // Save to default path: ./dump/backtest/my-strategy.md
          * await Backtest.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
@@ -9551,8 +12510,11 @@ class LiveUtils {
             return () => {
                 backtest$1.strategyGlobalService.stop(context.strategyName);
                 backtest$1.strategyGlobalService
-                    .getPendingSignal(symbol, new Date(), false)
-                    .then(async () => {
+                    .getPendingSignal(context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
                     if (!isDone) {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
@@ -9606,11 +12568,11 @@ class LiveUtils {
          * Saves strategy report to disk.
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Optional directory path to save report (default: "./logs/live")
+         * @param path - Optional directory path to save report (default: "./dump/live")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/live/my-strategy.md
+         * // Save to default path: ./dump/live/my-strategy.md
          * await Live.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
@@ -9646,7 +12608,6 @@ const Live = new LiveUtils();
 const SCHEDULE_METHOD_NAME_GET_DATA = "ScheduleUtils.getData";
 const SCHEDULE_METHOD_NAME_GET_REPORT = "ScheduleUtils.getReport";
 const SCHEDULE_METHOD_NAME_DUMP = "ScheduleUtils.dump";
-const SCHEDULE_METHOD_NAME_CLEAR = "ScheduleUtils.clear";
 /**
  * Utility class for scheduled signals reporting operations.
  *
@@ -9714,11 +12675,11 @@ class ScheduleUtils {
          * Saves strategy report to disk.
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Optional directory path to save report (default: "./logs/schedule")
+         * @param path - Optional directory path to save report (default: "./dump/schedule")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/schedule/my-strategy.md
+         * // Save to default path: ./dump/schedule/my-strategy.md
          * await Schedule.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
@@ -9732,28 +12693,6 @@ class ScheduleUtils {
             });
             await backtest$1.scheduleMarkdownService.dump(strategyName, path);
         };
-        /**
-         * Clears accumulated scheduled signal data from storage.
-         * If strategyName is provided, clears only that strategy's data.
-         * If strategyName is omitted, clears all strategies' data.
-         *
-         * @param strategyName - Optional strategy name to clear specific strategy data
-         *
-         * @example
-         * ```typescript
-         * // Clear specific strategy data
-         * await Schedule.clear("my-strategy");
-         *
-         * // Clear all strategies' data
-         * await Schedule.clear();
-         * ```
-         */
-        this.clear = async (strategyName) => {
-            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_CLEAR, {
-                strategyName,
-            });
-            await backtest$1.scheduleMarkdownService.clear(strategyName);
-        };
     }
 }
 /**
@@ -9860,21 +12799,21 @@ class Performance {
      * Saves performance report to disk.
      *
      * Creates directory if it doesn't exist.
-     * Default path: ./logs/performance/{strategyName}.md
+     * Default path: ./dump/performance/{strategyName}.md
      *
      * @param strategyName - Strategy name to save report for
      * @param path - Optional custom directory path
      *
      * @example
      * ```typescript
-     * // Save to default path: ./logs/performance/my-strategy.md
+     * // Save to default path: ./dump/performance/my-strategy.md
      * await Performance.dump("my-strategy");
      *
      * // Save to custom path: ./reports/perf/my-strategy.md
      * await Performance.dump("my-strategy", "./reports/perf");
      * ```
      */
-    static async dump(strategyName, path = "./logs/performance") {
+    static async dump(strategyName, path = "./dump/performance") {
         return backtest$1.performanceMarkdownService.dump(strategyName, path);
     }
     /**
@@ -9988,25 +12927,39 @@ class WalkerUtils {
             });
             const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             let isStopped = false;
+            let isDone = false;
             const task = async () => {
                 for await (const _ of this.run(symbol, context)) {
                     if (isStopped) {
                         break;
                     }
                 }
-                await doneWalkerSubject.next({
-                    exchangeName: walkerSchema.exchangeName,
-                    strategyName: context.walkerName,
-                    backtest: true,
-                    symbol,
-                });
+                if (!isDone) {
+                    await doneWalkerSubject.next({
+                        exchangeName: walkerSchema.exchangeName,
+                        strategyName: context.walkerName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                isStopped = true;
                 for (const strategyName of walkerSchema.strategies) {
                     backtest$1.strategyGlobalService.stop(strategyName);
                 }
+                walkerStopSubject.next(context.walkerName);
+                if (!isDone) {
+                    doneWalkerSubject.next({
+                        exchangeName: walkerSchema.exchangeName,
+                        strategyName: context.walkerName,
+                        backtest: true,
+                        symbol,
+                    });
+                }
+                isDone = true;
+                isStopped = true;
             };
         };
         /**
@@ -10062,11 +13015,11 @@ class WalkerUtils {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
-         * @param path - Optional directory path to save report (default: "./logs/walker")
+         * @param path - Optional directory path to save report (default: "./dump/walker")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/walker/my-walker.md
+         * // Save to default path: ./dump/walker/my-walker.md
          * await Walker.dump("BTCUSDT", "my-walker");
          *
          * // Save to custom path: ./custom/path/my-walker.md
@@ -10195,11 +13148,11 @@ class HeatUtils {
          * Default filename: {strategyName}.md
          *
          * @param strategyName - Strategy name to save heatmap report for
-         * @param path - Optional directory path to save report (default: "./logs/heatmap")
+         * @param path - Optional directory path to save report (default: "./dump/heatmap")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/heatmap/my-strategy.md
+         * // Save to default path: ./dump/heatmap/my-strategy.md
          * await Heat.dump("my-strategy");
          *
          * // Save to custom path: ./reports/my-strategy.md
@@ -10362,4 +13315,258 @@ PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, cont
 };
 const PositionSize = PositionSizeUtils;
 
-export { Backtest, ExecutionContextService, Heat, Live, MethodContextService, Performance, PersistBase, PersistRiskAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listRisks, listSizings, listStrategies, listWalkers, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPerformance, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, setConfig, setLogger };
+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) => {
+            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
+            return await backtest$1.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) => {
+            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
+                symbol,
+                context,
+            });
+            return await backtest$1.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) => {
+            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
+            await backtest$1.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";
+/**
+ * Utility class for accessing partial profit/loss reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by PartialMarkdownService from partial profit/loss events.
+ *
+ * Features:
+ * - Statistical data extraction (total profit/loss events count)
+ * - Markdown report generation with event tables
+ * - File export to disk
+ *
+ * Data source:
+ * - PartialMarkdownService listens to partialProfitSubject/partialLossSubject
+ * - Accumulates events in ReportStorage (max 250 events per symbol)
+ * - Events include: timestamp, action, symbol, signalId, position, level, price, mode
+ *
+ * @example
+ * ```typescript
+ * import { Partial } from "./classes/Partial";
+ *
+ * // Get statistical data for BTCUSDT
+ * const stats = await Partial.getData("BTCUSDT");
+ * console.log(`Total events: ${stats.totalEvents}`);
+ * console.log(`Profit events: ${stats.totalProfit}`);
+ * console.log(`Loss events: ${stats.totalLoss}`);
+ *
+ * // Generate markdown report
+ * const markdown = await Partial.getReport("BTCUSDT");
+ * console.log(markdown); // Formatted table with all events
+ *
+ * // Export report to file
+ * await Partial.dump("BTCUSDT"); // Saves to ./dump/partial/BTCUSDT.md
+ * await Partial.dump("BTCUSDT", "./custom/path"); // Custom directory
+ * ```
+ */
+class PartialUtils {
+    constructor() {
+        /**
+         * Retrieves statistical data from accumulated partial profit/loss events.
+         *
+         * Delegates to PartialMarkdownService.getData() which reads from ReportStorage.
+         * Returns aggregated metrics calculated from all profit and loss events.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @returns Promise resolving to PartialStatistics object with counts and event list
+         *
+         * @example
+         * ```typescript
+         * const stats = await Partial.getData("BTCUSDT");
+         *
+         * console.log(`Total events: ${stats.totalEvents}`);
+         * console.log(`Profit events: ${stats.totalProfit} (${(stats.totalProfit / stats.totalEvents * 100).toFixed(1)}%)`);
+         * console.log(`Loss events: ${stats.totalLoss} (${(stats.totalLoss / stats.totalEvents * 100).toFixed(1)}%)`);
+         *
+         * // Iterate through all events
+         * for (const event of stats.eventList) {
+         *   console.log(`${event.action.toUpperCase()}: Signal ${event.signalId} reached ${event.level}%`);
+         * }
+         * ```
+         */
+        this.getData = async (symbol) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol });
+            return await backtest$1.partialMarkdownService.getData(symbol);
+        };
+        /**
+         * Generates markdown report with all partial profit/loss events for a symbol.
+         *
+         * Creates formatted table containing:
+         * - Action (PROFIT/LOSS)
+         * - Symbol
+         * - Signal ID
+         * - Position (LONG/SHORT)
+         * - Level % (+10%, -20%, etc)
+         * - Current Price
+         * - Timestamp (ISO 8601)
+         * - Mode (Backtest/Live)
+         *
+         * Also includes summary statistics at the end.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Partial.getReport("BTCUSDT");
+         * console.log(markdown);
+         *
+         * // Output:
+         * // # Partial Profit/Loss Report: BTCUSDT
+         * //
+         * // | Action | Symbol | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
+         * // | --- | --- | --- | --- | --- | --- | --- | --- |
+         * // | PROFIT | BTCUSDT | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
+         * // | LOSS | BTCUSDT | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
+         * //
+         * // **Total events:** 2
+         * // **Profit events:** 1
+         * // **Loss events:** 1
+         * ```
+         */
+        this.getReport = async (symbol) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol });
+            return await backtest$1.partialMarkdownService.getReport(symbol);
+        };
+        /**
+         * Generates and saves markdown report to file.
+         *
+         * Creates directory if it doesn't exist.
+         * Filename format: {symbol}.md (e.g., "BTCUSDT.md")
+         *
+         * Delegates to PartialMarkdownService.dump() which:
+         * 1. Generates markdown report via getReport()
+         * 2. Creates output directory (recursive mkdir)
+         * 3. Writes file with UTF-8 encoding
+         * 4. Logs success/failure to console
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param path - Output directory path (default: "./dump/partial")
+         * @returns Promise that resolves when file is written
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/partial/BTCUSDT.md
+         * await Partial.dump("BTCUSDT");
+         *
+         * // Save to custom path: ./reports/partial/BTCUSDT.md
+         * await Partial.dump("BTCUSDT", "./reports/partial");
+         *
+         * // After multiple symbols backtested, export all reports
+         * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+         *   await Partial.dump(symbol, "./backtest-results");
+         * }
+         * ```
+         */
+        this.dump = async (symbol, path) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, path });
+            await backtest$1.partialMarkdownService.dump(symbol, path);
+        };
+    }
+}
+/**
+ * Global singleton instance of PartialUtils.
+ * Provides static-like access to partial profit/loss reporting methods.
+ *
+ * @example
+ * ```typescript
+ * import { Partial } from "backtest-kit";
+ *
+ * // Usage same as PartialUtils methods
+ * const stats = await Partial.getData("BTCUSDT");
+ * const report = await Partial.getReport("BTCUSDT");
+ * await Partial.dump("BTCUSDT");
+ * ```
+ */
+const Partial = new PartialUtils();
+
+export { Backtest, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };