backtest-kit 1.3.2 → 1.4.0

package/build/index.cjs

@@ -118,6 +118,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'),
@@ -126,6 +128,7 @@ const schemaServices$1 = {
     walkerSchemaService: Symbol('walkerSchemaService'),
     sizingSchemaService: Symbol('sizingSchemaService'),
     riskSchemaService: Symbol('riskSchemaService'),
+    optimizerSchemaService: Symbol('optimizerSchemaService'),
 };
 const globalServices$1 = {
     exchangeGlobalService: Symbol('exchangeGlobalService'),
@@ -133,6 +136,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'),
@@ -156,6 +161,7 @@ const markdownServices$1 = {
     performanceMarkdownService: Symbol('performanceMarkdownService'),
     walkerMarkdownService: Symbol('walkerMarkdownService'),
     heatMarkdownService: Symbol('heatMarkdownService'),
+    partialMarkdownService: Symbol('partialMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -164,6 +170,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,
@@ -176,6 +186,7 @@ const TYPES = {
     ...logicPublicServices$1,
     ...markdownServices$1,
     ...validationServices$1,
+    ...templateServices$1,
 };
 
 /**
@@ -877,6 +888,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";
@@ -942,7 +959,7 @@ const PersistBase = functoolsKit.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 = path.join(process.cwd(), "logs/data")) {
         this.entityName = entityName;
@@ -1201,7 +1218,7 @@ class PersistSignalUtils {
         this.PersistSignalFactory = PersistBase;
         this.getSignalStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, (strategyName) => Reflect.construct(this.PersistSignalFactory, [
             strategyName,
-            `./logs/data/signal/`,
+            `./dump/data/signal/`,
         ]));
         /**
          * Reads persisted signal data for a strategy and symbol.
@@ -1297,7 +1314,7 @@ class PersistRiskUtils {
         this.PersistRiskFactory = PersistBase;
         this.getRiskStorage = functoolsKit.memoize(([riskName]) => `${riskName}`, (riskName) => Reflect.construct(this.PersistRiskFactory, [
             riskName,
-            `./logs/data/risk/`,
+            `./dump/data/risk/`,
         ]));
         /**
          * Reads persisted active positions for a risk profile.
@@ -1374,6 +1391,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 = functoolsKit.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 = functoolsKit.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).
@@ -1414,7 +1617,12 @@ const doneWalkerSubject = new functoolsKit.Subject();
  * Progress emitter for backtest execution progress.
  * Emits progress updates during backtest execution.
  */
-const progressEmitter = new functoolsKit.Subject();
+const progressBacktestEmitter = new functoolsKit.Subject();
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+const progressWalkerEmitter = new functoolsKit.Subject();
 /**
  * Performance emitter for execution metrics.
  * Emits performance metrics for profiling and bottleneck detection.
@@ -1440,6 +1648,16 @@ const walkerStopSubject = new functoolsKit.Subject();
  * Emits when risk validation functions throw errors during signal checking.
  */
 const validationSubject = new functoolsKit.Subject();
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+const partialProfitSubject = new functoolsKit.Subject();
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+const partialLossSubject = new functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1447,8 +1665,11 @@ 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,
@@ -1468,6 +1689,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})`);
@@ -1717,26 +1957,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) => {
@@ -1753,7 +2009,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);
     }
@@ -1808,7 +2064,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,
@@ -1829,7 +2085,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()
@@ -1857,10 +2113,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,
@@ -1998,6 +2254,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,
@@ -2020,6 +2278,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,
@@ -2058,7 +2344,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);
     }
@@ -2083,7 +2369,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
@@ -2108,10 +2394,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,
@@ -2147,6 +2433,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,
@@ -2288,6 +2576,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;
 };
@@ -2334,7 +2649,7 @@ class ClientStrategy {
          *
          * @returns Promise that resolves when initialization is complete
          */
-        this.waitForInit = functoolsKit.singleshot(async () => await WAIT_FOR_INIT_FN$1(this));
+        this.waitForInit = functoolsKit.singleshot(async () => await WAIT_FOR_INIT_FN$2(this));
     }
     /**
      * Updates pending signal and persists to disk in live mode.
@@ -2360,6 +2675,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.
@@ -2434,7 +2768,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);
@@ -2610,7 +2944,7 @@ class ClientStrategy {
         this._isStopped = true;
         // Clear scheduled signal if exists
         if (this._scheduledSignal) {
-            this._scheduledSignal = null;
+            await this.setScheduledSignal(null);
         }
     }
 }
@@ -2649,6 +2983,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.
          *
@@ -2665,6 +3000,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,
@@ -3151,7 +3487,7 @@ const DO_VALIDATION_FN = functoolsKit.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);
@@ -3182,7 +3518,7 @@ class ClientRisk {
          * Uses singleshot pattern to ensure initialization happens exactly once.
          * Skips persistence in backtest mode.
          */
-        this.waitForInit = functoolsKit.singleshot(async () => await WAIT_FOR_INIT_FN(this));
+        this.waitForInit = functoolsKit.singleshot(async () => await WAIT_FOR_INIT_FN$1(this));
         /**
          * Checks if a signal should be allowed based on risk limits.
          *
@@ -4357,7 +4693,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,
@@ -4491,7 +4827,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,
@@ -4732,6 +5068,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);
@@ -5077,7 +5423,7 @@ function isUnsafe$3(value) {
     }
     return false;
 }
-const columns$3 = [
+const columns$4 = [
     {
         key: "signalId",
         label: "Signal ID",
@@ -5155,7 +5501,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 = [];
@@ -5245,9 +5591,9 @@ let ReportStorage$3 = class ReportStorage {
         if (stats.totalSignals === 0) {
             return functoolsKit.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 = functoolsKit.str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return functoolsKit.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)`}`);
@@ -5256,9 +5602,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$1 = "./logs/backtest") {
+    async dump(strategyName, path$1 = "./dump/backtest") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = path.join(process.cwd(), path$1);
@@ -5308,7 +5654,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -5386,20 +5732,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,
@@ -5467,7 +5813,7 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$2 = [
+const columns$3 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -5541,12 +5887,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 = [];
@@ -5574,7 +5920,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();
             }
         }
@@ -5598,7 +5944,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();
         }
     }
@@ -5630,7 +5976,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();
             }
         }
@@ -5668,7 +6014,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();
             }
         }
@@ -5765,9 +6111,9 @@ let ReportStorage$2 = class ReportStorage {
         if (stats.totalEvents === 0) {
             return functoolsKit.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 = functoolsKit.str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return functoolsKit.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)`}`);
@@ -5776,9 +6122,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$1 = "./logs/live") {
+    async dump(strategyName, path$1 = "./dump/live") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = path.join(process.cwd(), path$1);
@@ -5831,7 +6177,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
+        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -5919,20 +6265,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,
@@ -5982,7 +6328,7 @@ class LiveMarkdownService {
     }
 }
 
-const columns$1 = [
+const columns$2 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -6040,12 +6386,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 = [];
@@ -6069,7 +6415,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();
         }
     }
@@ -6105,7 +6451,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();
             }
         }
@@ -6157,9 +6503,9 @@ let ReportStorage$1 = class ReportStorage {
         if (stats.totalEvents === 0) {
             return functoolsKit.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 = functoolsKit.str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
         return functoolsKit.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`}`);
@@ -6168,9 +6514,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$1 = "./logs/schedule") {
+    async dump(strategyName, path$1 = "./dump/schedule") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = path.join(process.cwd(), path$1);
@@ -6214,7 +6560,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$1());
+        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
         /**
          * Processes tick events and accumulates scheduled/cancelled events.
          * Should be called from signalLiveEmitter subscription.
@@ -6289,20 +6635,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,
@@ -6362,7 +6708,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.
@@ -6380,7 +6726,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();
         }
     }
@@ -6519,7 +6865,7 @@ class PerformanceStorage {
      * @param strategyName - Strategy name
      * @param path - Directory path to save report
      */
-    async dump(strategyName, path$1 = "./logs/performance") {
+    async dump(strategyName, path$1 = "./dump/performance") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = path.join(process.cwd(), path$1);
@@ -6632,14 +6978,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,
@@ -6701,7 +7047,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) */
@@ -6769,9 +7115,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$1 = "./logs/walker") {
+    async dump(symbol, metric, context, path$1 = "./dump/walker") {
         const markdown = await this.getReport(symbol, metric, context);
         try {
             const dir = path.join(process.cwd(), path$1);
@@ -6785,7 +7131,7 @@ class ReportStorage {
             console.error(`Failed to save walker report:`, error);
         }
     }
-}
+};
 /**
  * Service for generating and saving walker markdown reports.
  *
@@ -6810,7 +7156,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage(walkerName));
+        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$1(walkerName));
         /**
          * Processes walker progress events and accumulates strategy results.
          * Should be called from walkerEmitter.
@@ -6893,20 +7239,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,
@@ -6981,7 +7327,7 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns = [
+const columns$1 = [
     {
         key: "symbol",
         label: "Symbol",
@@ -7277,9 +7623,9 @@ class HeatmapStorage {
         if (data.symbols.length === 0) {
             return functoolsKit.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 = functoolsKit.str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
         return functoolsKit.str.newline(`# Portfolio Heatmap: ${strategyName}`, "", `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%+.2f%%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio, "%.2f") : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`, "", table);
@@ -7288,9 +7634,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$1 = "./logs/heatmap") {
+    async dump(strategyName, path$1 = "./dump/heatmap") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = path.join(process.cwd(), path$1);
@@ -7421,20 +7767,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,
@@ -7866,47 +8212,2310 @@ 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());
-    provide(TYPES.strategyGlobalService, () => new StrategyGlobalService());
-    provide(TYPES.frameGlobalService, () => new FrameGlobalService());
-    provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
-    provide(TYPES.riskGlobalService, () => new RiskGlobalService());
-}
-{
-    provide(TYPES.liveCommandService, () => new LiveCommandService());
-    provide(TYPES.backtestCommandService, () => new BacktestCommandService());
-    provide(TYPES.walkerCommandService, () => new WalkerCommandService());
-}
-{
-    provide(TYPES.backtestLogicPrivateService, () => new BacktestLogicPrivateService());
-    provide(TYPES.liveLogicPrivateService, () => new LiveLogicPrivateService());
-    provide(TYPES.walkerLogicPrivateService, () => new WalkerLogicPrivateService());
-}
-{
-    provide(TYPES.backtestLogicPublicService, () => new BacktestLogicPublicService());
+/**
+ * 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 functoolsKit.ToolRegistry("optimizerSchema");
+        /**
+         * Registers a new optimizer schema.
+         * Validates required fields before registration.
+         *
+         * @param key - Unique optimizer name
+         * @param value - Optimizer schema configuration
+         * @throws Error if schema validation fails
+         */
+        this.register = (key, value) => {
+            this.loggerService.log(`optimizerSchemaService register`, { key });
+            this.validateShallow(value);
+            this._registry = this._registry.register(key, value);
+        };
+        /**
+         * Validates optimizer schema structure.
+         * Checks required fields: optimizerName, rangeTrain, source, getPrompt.
+         *
+         * @param optimizerSchema - Schema to validate
+         * @throws Error if validation fails
+         */
+        this.validateShallow = (optimizerSchema) => {
+            this.loggerService.log(`optimizerTemplateService validateShallow`, {
+                optimizerSchema,
+            });
+            if (typeof optimizerSchema.optimizerName !== "string") {
+                throw new Error(`optimizer template validation failed: missing optimizerName`);
+            }
+            if (!Array.isArray(optimizerSchema.rangeTrain) || optimizerSchema.rangeTrain.length === 0) {
+                throw new Error(`optimizer template validation failed: rangeTrain must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+            if (!Array.isArray(optimizerSchema.source) || optimizerSchema.source.length === 0) {
+                throw new Error(`optimizer template validation failed: source must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+            if (typeof optimizerSchema.getPrompt !== "function") {
+                throw new Error(`optimizer template validation failed: getPrompt must be a function for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+        };
+        /**
+         * Partially overrides an existing optimizer schema.
+         * Merges provided values with existing schema.
+         *
+         * @param key - Optimizer name to override
+         * @param value - Partial schema values to merge
+         * @returns Updated complete schema
+         * @throws Error if optimizer not found
+         */
+        this.override = (key, value) => {
+            this.loggerService.log(`optimizerSchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        /**
+         * Retrieves optimizer schema by name.
+         *
+         * @param key - Optimizer name
+         * @returns Complete optimizer schema
+         * @throws Error if optimizer not found
+         */
+        this.get = (key) => {
+            this.loggerService.log(`optimizerSchemaService get`, { key });
+            return this._registry.get(key);
+        };
+    }
+}
+
+/**
+ * Service for validating optimizer existence and managing optimizer registry.
+ * Maintains a Map of registered optimizers for validation purposes.
+ *
+ * Uses memoization for efficient repeated validation checks.
+ */
+class OptimizerValidationService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._optimizerMap = new Map();
+        /**
+         * Adds optimizer to validation registry.
+         * Prevents duplicate optimizer names.
+         *
+         * @param optimizerName - Unique optimizer identifier
+         * @param optimizerSchema - Complete optimizer schema
+         * @throws Error if optimizer with same name already exists
+         */
+        this.addOptimizer = (optimizerName, optimizerSchema) => {
+            this.loggerService.log("optimizerValidationService addOptimizer", {
+                optimizerName,
+                optimizerSchema,
+            });
+            if (this._optimizerMap.has(optimizerName)) {
+                throw new Error(`optimizer ${optimizerName} already exist`);
+            }
+            this._optimizerMap.set(optimizerName, optimizerSchema);
+        };
+        /**
+         * Validates that optimizer exists in registry.
+         * Memoized for performance on repeated checks.
+         *
+         * @param optimizerName - Optimizer name to validate
+         * @param source - Source method name for error messages
+         * @throws Error if optimizer not found
+         */
+        this.validate = functoolsKit.memoize(([optimizerName]) => optimizerName, (optimizerName, source) => {
+            this.loggerService.log("optimizerValidationService validate", {
+                optimizerName,
+                source,
+            });
+            const optimizer = this._optimizerMap.get(optimizerName);
+            if (!optimizer) {
+                throw new Error(`optimizer ${optimizerName} not found source=${source}`);
+            }
+            return true;
+        });
+        /**
+         * Lists all registered optimizer schemas.
+         *
+         * @returns Array of all optimizer schemas
+         */
+        this.list = async () => {
+            this.loggerService.log("optimizerValidationService list");
+            return Array.from(this._optimizerMap.values());
+        };
+    }
+}
+
+const METHOD_NAME_GET_DATA = "optimizerGlobalService getData";
+const METHOD_NAME_GET_CODE = "optimizerGlobalService getCode";
+const METHOD_NAME_DUMP = "optimizerGlobalService dump";
+/**
+ * Global service for optimizer operations with validation.
+ * Entry point for public API, performs validation before delegating to ConnectionService.
+ *
+ * Workflow:
+ * 1. Log operation
+ * 2. Validate optimizer exists
+ * 3. Delegate to OptimizerConnectionService
+ */
+class OptimizerGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.optimizerConnectionService = inject(TYPES.optimizerConnectionService);
+        this.optimizerValidationService = inject(TYPES.optimizerValidationService);
+        /**
+         * Fetches data from all sources and generates strategy metadata.
+         * Validates optimizer existence before execution.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Array of generated strategies with conversation context
+         * @throws Error if optimizer not found
+         */
+        this.getData = async (symbol, optimizerName) => {
+            this.loggerService.log(METHOD_NAME_GET_DATA, {
+                symbol,
+                optimizerName,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_DATA);
+            return await this.optimizerConnectionService.getData(symbol, optimizerName);
+        };
+        /**
+         * Generates complete executable strategy code.
+         * Validates optimizer existence before execution.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Generated TypeScript/JavaScript code as string
+         * @throws Error if optimizer not found
+         */
+        this.getCode = async (symbol, optimizerName) => {
+            this.loggerService.log(METHOD_NAME_GET_CODE, {
+                symbol,
+                optimizerName,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_CODE);
+            return await this.optimizerConnectionService.getCode(symbol, optimizerName);
+        };
+        /**
+         * Generates and saves strategy code to file.
+         * Validates optimizer existence before execution.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @param path - Output directory path (optional)
+         * @throws Error if optimizer not found
+         */
+        this.dump = async (symbol, optimizerName, path) => {
+            this.loggerService.log(METHOD_NAME_DUMP, {
+                symbol,
+                optimizerName,
+                path,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_DUMP);
+            return await this.optimizerConnectionService.dump(symbol, optimizerName, path);
+        };
+    }
+}
+
+const ITERATION_LIMIT = 25;
+const DEFAULT_SOURCE_NAME = "unknown";
+const CREATE_PREFIX_FN = () => (Math.random() + 1).toString(36).substring(7);
+/**
+ * Default user message formatter.
+ * Delegates to template's getUserMessage method.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Fetched data array
+ * @param name - Source name
+ * @param self - ClientOptimizer instance
+ * @returns Formatted user message content
+ */
+const DEFAULT_USER_FN = async (symbol, data, name, self) => {
+    return await self.params.template.getUserMessage(symbol, data, name);
+};
+/**
+ * Default assistant message formatter.
+ * Delegates to template's getAssistantMessage method.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Fetched data array
+ * @param name - Source name
+ * @param self - ClientOptimizer instance
+ * @returns Formatted assistant message content
+ */
+const DEFAULT_ASSISTANT_FN = async (symbol, data, name, self) => {
+    return await self.params.template.getAssistantMessage(symbol, data, name);
+};
+/**
+ * Resolves paginated data from source with deduplication.
+ * Uses iterateDocuments to handle pagination automatically.
+ *
+ * @param fetch - Source fetch function
+ * @param filterData - Filter arguments (symbol, dates)
+ * @returns Deduplicated array of all fetched data
+ */
+const RESOLVE_PAGINATION_FN = async (fetch, filterData) => {
+    const iterator = functoolsKit.iterateDocuments({
+        limit: ITERATION_LIMIT,
+        async createRequest({ limit, offset }) {
+            return await fetch({
+                symbol: filterData.symbol,
+                startDate: filterData.startDate,
+                endDate: filterData.endDate,
+                limit,
+                offset,
+            });
+        },
+    });
+    const distinct = functoolsKit.distinctDocuments(iterator, (data) => data.id);
+    return await functoolsKit.resolveDocuments(distinct);
+};
+/**
+ * Collects data from all sources and generates strategy metadata.
+ * Iterates through training ranges, fetches data from each source,
+ * builds LLM conversation history, and generates strategy prompts.
+ *
+ * @param symbol - Trading pair symbol
+ * @param self - ClientOptimizer instance
+ * @returns Array of generated strategies with conversation context
+ */
+const GET_STRATEGY_DATA_FN = async (symbol, self) => {
+    const strategyList = [];
+    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$1, self) => {
+    const report = await self.getCode(symbol);
+    try {
+        const dir = path.join(process.cwd(), path$1);
+        await fs.mkdir(dir, { recursive: true });
+        const filename = `${self.params.optimizerName}_${symbol}.mjs`;
+        const filepath = path.join(dir, filename);
+        await fs.writeFile(filepath, report, "utf-8");
+        self.params.logger.info(`Optimizer report saved: ${filepath}`);
+        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 = functoolsKit.memoize(([optimizerName]) => `${optimizerName}`, (optimizerName) => {
+            const { getPrompt, rangeTest, rangeTrain, source, template: rawTemplate = {}, callbacks } = this.optimizerSchemaService.get(optimizerName);
+            const { getAssistantMessage = this.optimizerTemplateService.getAssistantMessage, getExchangeTemplate = this.optimizerTemplateService.getExchangeTemplate, getFrameTemplate = this.optimizerTemplateService.getFrameTemplate, getJsonDumpTemplate = this.optimizerTemplateService.getJsonDumpTemplate, getJsonTemplate = this.optimizerTemplateService.getJsonTemplate, getLauncherTemplate = this.optimizerTemplateService.getLauncherTemplate, getStrategyTemplate = this.optimizerTemplateService.getStrategyTemplate, getTextTemplate = this.optimizerTemplateService.getTextTemplate, getWalkerTemplate = this.optimizerTemplateService.getWalkerTemplate, getTopBanner = this.optimizerTemplateService.getTopBanner, getUserMessage = this.optimizerTemplateService.getUserMessage, } = rawTemplate;
+            const template = {
+                getAssistantMessage,
+                getExchangeTemplate,
+                getFrameTemplate,
+                getJsonDumpTemplate,
+                getJsonTemplate,
+                getLauncherTemplate,
+                getStrategyTemplate,
+                getTextTemplate,
+                getWalkerTemplate,
+                getTopBanner,
+                getUserMessage,
+            };
+            return new ClientOptimizer({
+                optimizerName,
+                logger: this.loggerService,
+                getPrompt,
+                rangeTest,
+                rangeTrain,
+                source,
+                template,
+                callbacks,
+            });
+        });
+        /**
+         * 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 = functoolsKit.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 = functoolsKit.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 functoolsKit.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 = functoolsKit.str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
+        return functoolsKit.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$1 = "./dump/partial") {
+        const markdown = await this.getReport(symbol);
+        try {
+            const dir = path.join(process.cwd(), path$1);
+            await fs.mkdir(dir, { recursive: true });
+            const filename = `${symbol}.md`;
+            const filepath = path.join(dir, filename);
+            await fs.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 = functoolsKit.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 = functoolsKit.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());
+    provide(TYPES.backtestCommandService, () => new BacktestCommandService());
+    provide(TYPES.walkerCommandService, () => new WalkerCommandService());
+}
+{
+    provide(TYPES.backtestLogicPrivateService, () => new BacktestLogicPrivateService());
+    provide(TYPES.liveLogicPrivateService, () => new LiveLogicPrivateService());
+    provide(TYPES.walkerLogicPrivateService, () => new WalkerLogicPrivateService());
+}
+{
+    provide(TYPES.backtestLogicPublicService, () => new BacktestLogicPublicService());
     provide(TYPES.liveLogicPublicService, () => new LiveLogicPublicService());
     provide(TYPES.walkerLogicPublicService, () => new WalkerLogicPublicService());
 }
@@ -7917,6 +10526,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());
@@ -7925,6 +10535,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 = {
@@ -7940,6 +10554,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),
@@ -7948,6 +10564,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),
@@ -7955,6 +10572,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),
@@ -7978,6 +10597,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),
@@ -7986,6 +10606,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,
@@ -7998,6 +10622,7 @@ const backtest = {
     ...logicPublicServices,
     ...markdownServices,
     ...validationServices,
+    ...templateServices,
 };
 init();
 var backtest$1 = backtest;
@@ -8043,6 +10668,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.
  *
@@ -8331,8 +10957,102 @@ function addRisk(riskSchema) {
     backtest$1.loggerService.info(ADD_RISK_METHOD_NAME, {
         riskSchema,
     });
-    backtest$1.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
-    backtest$1.riskSchemaService.register(riskSchema.riskName, 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";
@@ -8341,6 +11061,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.
  *
@@ -8538,6 +11259,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";
@@ -8552,12 +11313,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.
  *
@@ -8943,9 +11709,9 @@ function listenDoneWalkerOnce(filterFn, fn) {
  *
  * @example
  * ```typescript
- * import { listenProgress, Backtest } from "backtest-kit";
+ * import { listenBacktestProgress, Backtest } from "backtest-kit";
  *
- * const unsubscribe = listenProgress((event) => {
+ * 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}`);
@@ -8961,9 +11727,43 @@ function listenDoneWalkerOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenProgress(fn) {
+function listenBacktestProgress(fn) {
     backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
-    return progressEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
+    return progressBacktestEmitter.subscribe(functoolsKit.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 { listenWalkerProgress, Walker } from "backtest-kit";
+ *
+ * const unsubscribe = 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}`);
+ * });
+ *
+ * Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenWalkerProgress(fn) {
+    backtest$1.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
+    return progressWalkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
  * Subscribes to performance metric events with queued async processing.
@@ -9141,6 +11941,130 @@ function listenValidation(fn) {
     backtest$1.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
     return validationSubject.subscribe(functoolsKit.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(functoolsKit.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(functoolsKit.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";
@@ -9437,11 +12361,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
@@ -9646,11 +12570,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
@@ -9686,7 +12610,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.
  *
@@ -9754,11 +12677,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
@@ -9772,28 +12695,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);
-        };
     }
 }
 /**
@@ -9900,21 +12801,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);
     }
     /**
@@ -10116,11 +13017,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
@@ -10249,11 +13150,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
@@ -10416,20 +13317,279 @@ PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, cont
 };
 const PositionSize = PositionSizeUtils;
 
+const OPTIMIZER_METHOD_NAME_GET_DATA = "OptimizerUtils.getData";
+const OPTIMIZER_METHOD_NAME_GET_CODE = "OptimizerUtils.getCode";
+const OPTIMIZER_METHOD_NAME_DUMP = "OptimizerUtils.dump";
+/**
+ * Public API utilities for optimizer operations.
+ * Provides high-level methods for strategy generation and code export.
+ *
+ * Usage:
+ * ```typescript
+ * import { Optimizer } from "backtest-kit";
+ *
+ * // Get strategy data
+ * const strategies = await Optimizer.getData("BTCUSDT", {
+ *   optimizerName: "my-optimizer"
+ * });
+ *
+ * // Generate code
+ * const code = await Optimizer.getCode("BTCUSDT", {
+ *   optimizerName: "my-optimizer"
+ * });
+ *
+ * // Save to file
+ * await Optimizer.dump("BTCUSDT", {
+ *   optimizerName: "my-optimizer"
+ * }, "./output");
+ * ```
+ */
+class OptimizerUtils {
+    constructor() {
+        /**
+         * Fetches data from all sources and generates strategy metadata.
+         * Processes each training range and builds LLM conversation history.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with optimizerName
+         * @returns Array of generated strategies with conversation context
+         * @throws Error if optimizer not found
+         */
+        this.getData = async (symbol, context) => {
+            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();
+
 exports.Backtest = Backtest;
 exports.ExecutionContextService = ExecutionContextService;
 exports.Heat = Heat;
 exports.Live = Live;
 exports.MethodContextService = MethodContextService;
+exports.Optimizer = Optimizer;
+exports.Partial = Partial;
 exports.Performance = Performance;
 exports.PersistBase = PersistBase;
+exports.PersistPartialAdapter = PersistPartialAdapter;
 exports.PersistRiskAdapter = PersistRiskAdapter;
+exports.PersistScheduleAdapter = PersistScheduleAdapter;
 exports.PersistSignalAdapter = PersistSignalAdapter;
 exports.PositionSize = PositionSize;
 exports.Schedule = Schedule;
 exports.Walker = Walker;
 exports.addExchange = addExchange;
 exports.addFrame = addFrame;
+exports.addOptimizer = addOptimizer;
 exports.addRisk = addRisk;
 exports.addSizing = addSizing;
 exports.addStrategy = addStrategy;
@@ -10444,10 +13604,12 @@ exports.getMode = getMode;
 exports.lib = backtest;
 exports.listExchanges = listExchanges;
 exports.listFrames = listFrames;
+exports.listOptimizers = listOptimizers;
 exports.listRisks = listRisks;
 exports.listSizings = listSizings;
 exports.listStrategies = listStrategies;
 exports.listWalkers = listWalkers;
+exports.listenBacktestProgress = listenBacktestProgress;
 exports.listenDoneBacktest = listenDoneBacktest;
 exports.listenDoneBacktestOnce = listenDoneBacktestOnce;
 exports.listenDoneLive = listenDoneLive;
@@ -10455,8 +13617,11 @@ exports.listenDoneLiveOnce = listenDoneLiveOnce;
 exports.listenDoneWalker = listenDoneWalker;
 exports.listenDoneWalkerOnce = listenDoneWalkerOnce;
 exports.listenError = listenError;
+exports.listenPartialLoss = listenPartialLoss;
+exports.listenPartialLossOnce = listenPartialLossOnce;
+exports.listenPartialProfit = listenPartialProfit;
+exports.listenPartialProfitOnce = listenPartialProfitOnce;
 exports.listenPerformance = listenPerformance;
-exports.listenProgress = listenProgress;
 exports.listenSignal = listenSignal;
 exports.listenSignalBacktest = listenSignalBacktest;
 exports.listenSignalBacktestOnce = listenSignalBacktestOnce;
@@ -10467,5 +13632,6 @@ exports.listenValidation = listenValidation;
 exports.listenWalker = listenWalker;
 exports.listenWalkerComplete = listenWalkerComplete;
 exports.listenWalkerOnce = listenWalkerOnce;
+exports.listenWalkerProgress = listenWalkerProgress;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;