backtest-kit 1.3.2 → 1.4.1

package/types.d.ts

@@ -570,6 +570,162 @@ interface IRisk {
  */
 type RiskName = string;
 
+/**
+ * Profit or loss level milestone in percentage points.
+ * Represents 10%, 20%, 30%, ..., 100% profit or loss thresholds.
+ *
+ * Used to track when a signal reaches specific profit/loss milestones.
+ * Each level is emitted only once per signal (deduplication via Set).
+ *
+ * @example
+ * ```typescript
+ * const level: PartialLevel = 50; // 50% profit or loss milestone
+ * ```
+ */
+type PartialLevel = 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100;
+/**
+ * Serializable partial data for persistence layer.
+ * Converts Sets to arrays for JSON serialization.
+ *
+ * Stored in PersistPartialAdapter as Record<signalId, IPartialData>.
+ * Loaded on initialization and converted back to IPartialState.
+ */
+interface IPartialData {
+    /**
+     * Array of profit levels that have been reached for this signal.
+     * Serialized form of IPartialState.profitLevels Set.
+     */
+    profitLevels: PartialLevel[];
+    /**
+     * Array of loss levels that have been reached for this signal.
+     * Serialized form of IPartialState.lossLevels Set.
+     */
+    lossLevels: PartialLevel[];
+}
+/**
+ * Partial profit/loss tracking interface.
+ * Implemented by ClientPartial and PartialConnectionService.
+ *
+ * Tracks profit/loss level milestones for active trading signals.
+ * Emits events when signals reach 10%, 20%, 30%, etc profit or loss.
+ *
+ * @example
+ * ```typescript
+ * import { ClientPartial } from "./client/ClientPartial";
+ *
+ * const partial = new ClientPartial({
+ *   logger: loggerService,
+ *   onProfit: (symbol, data, price, level, backtest, timestamp) => {
+ *     console.log(`Signal ${data.id} reached ${level}% profit`);
+ *   },
+ *   onLoss: (symbol, data, price, level, backtest, timestamp) => {
+ *     console.log(`Signal ${data.id} reached ${level}% loss`);
+ *   }
+ * });
+ *
+ * await partial.waitForInit("BTCUSDT");
+ *
+ * // During signal monitoring
+ * await partial.profit("BTCUSDT", signal, 51000, 15.5, false, new Date());
+ * // Emits event when reaching 10% profit milestone
+ *
+ * // When signal closes
+ * await partial.clear("BTCUSDT", signal, 52000);
+ * ```
+ */
+interface IPartial {
+    /**
+     * Processes profit state and emits events for new profit levels reached.
+     *
+     * Called by ClientStrategy during signal monitoring when revenuePercent > 0.
+     * Checks which profit levels (10%, 20%, 30%, etc) have been reached
+     * and emits events for new levels only (Set-based deduplication).
+     *
+     * @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 opened at $50000, current price $51500
+     * // Revenue: 3% profit
+     * await partial.profit("BTCUSDT", signal, 51500, 3.0, false, new Date());
+     * // No events emitted (below 10% threshold)
+     *
+     * // Price rises to $55000
+     * // Revenue: 10% profit
+     * await partial.profit("BTCUSDT", signal, 55000, 10.0, false, new Date());
+     * // Emits partialProfitSubject event for 10% level
+     *
+     * // Price rises to $61000
+     * // Revenue: 22% profit
+     * await partial.profit("BTCUSDT", signal, 61000, 22.0, false, new Date());
+     * // Emits events for 20% level only (10% already emitted)
+     * ```
+     */
+    profit(symbol: string, data: ISignalRow, currentPrice: number, revenuePercent: number, backtest: boolean, when: Date): Promise<void>;
+    /**
+     * Processes loss state and emits events for new loss levels reached.
+     *
+     * Called by ClientStrategy during signal monitoring when revenuePercent < 0.
+     * Checks which loss levels (10%, 20%, 30%, etc) have been reached
+     * and emits events for new levels only (Set-based deduplication).
+     *
+     * @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 opened at $50000, current price $48000
+     * // Loss: -4% loss
+     * await partial.loss("BTCUSDT", signal, 48000, -4.0, false, new Date());
+     * // No events emitted (below -10% threshold)
+     *
+     * // Price drops to $45000
+     * // Loss: -10% loss
+     * await partial.loss("BTCUSDT", signal, 45000, -10.0, false, new Date());
+     * // Emits partialLossSubject event for 10% level
+     *
+     * // Price drops to $39000
+     * // Loss: -22% loss
+     * await partial.loss("BTCUSDT", signal, 39000, -22.0, false, new Date());
+     * // Emits events for 20% level only (10% already emitted)
+     * ```
+     */
+    loss(symbol: string, data: ISignalRow, currentPrice: number, lossPercent: number, backtest: boolean, when: Date): Promise<void>;
+    /**
+     * Clears partial profit/loss state when signal closes.
+     *
+     * Called by ClientStrategy when signal completes (TP/SL/time_expired).
+     * Removes signal state from memory and persists changes to disk.
+     * Cleans up memoized ClientPartial instance 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
+     *
+     * @example
+     * ```typescript
+     * // Signal closes at take profit
+     * await partial.clear("BTCUSDT", signal, 52000);
+     * // State removed from _states Map
+     * // Persisted to disk without this signal's data
+     * // Memoized instance cleared from getPartial cache
+     * ```
+     */
+    clear(symbol: string, data: ISignalRow, priceClose: number): Promise<void>;
+}
+
 /**
  * Signal generation interval for throttling.
  * Enforces minimum time between getSignal calls.
@@ -648,6 +804,10 @@ interface IStrategyCallbacks {
     onCancel: (symbol: string, data: IScheduledSignalRow, currentPrice: number, backtest: boolean) => void;
     /** Called when signal is written to persist storage (for testing) */
     onWrite: (symbol: string, data: ISignalRow | null, backtest: boolean) => void;
+    /** Called when signal is in partial profit state (price moved favorably but not reached TP yet) */
+    onPartialProfit: (symbol: string, data: ISignalRow, currentPrice: number, revenuePercent: number, backtest: boolean) => void;
+    /** Called when signal is in partial loss state (price moved against position but not hit SL yet) */
+    onPartialLoss: (symbol: string, data: ISignalRow, currentPrice: number, lossPercent: number, backtest: boolean) => void;
 }
 /**
  * Strategy schema registered via addStrategy().
@@ -1009,13 +1169,13 @@ declare 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
@@ -1333,6 +1493,418 @@ interface ISizing {
  */
 type SizingName = string;
 
+/**
+ * Message role type for LLM conversation context.
+ * Defines the sender of a message in a chat-based interaction.
+ */
+type MessageRole = "assistant" | "system" | "user";
+/**
+ * Message model for LLM conversation history.
+ * Used in Optimizer to build prompts and maintain conversation context.
+ */
+interface MessageModel {
+    /**
+     * The sender of the message.
+     * - "system": System instructions and context
+     * - "user": User input and questions
+     * - "assistant": LLM responses
+     */
+    role: MessageRole;
+    /**
+     * The text content of the message.
+     * Contains the actual message text sent or received.
+     */
+    content: string;
+}
+
+/**
+ * Unique identifier for data rows in optimizer sources.
+ * Can be either a string or numeric ID.
+ */
+type RowId = string | number;
+/**
+ * Time range configuration for optimizer training or testing periods.
+ * Used to define date boundaries for data collection.
+ */
+interface IOptimizerRange {
+    /**
+     * Optional description of this time range.
+     * Example: "Bull market period 2024-Q1"
+     */
+    note?: string;
+    /**
+     * Start date of the range (inclusive).
+     */
+    startDate: Date;
+    /**
+     * End date of the range (inclusive).
+     */
+    endDate: Date;
+}
+/**
+ * Base interface for optimizer data sources.
+ * All data fetched from sources must have a unique ID for deduplication.
+ */
+interface IOptimizerData {
+    /**
+     * Unique identifier for this data row.
+     * Used for deduplication when paginating data sources.
+     */
+    id: RowId;
+}
+/**
+ * Filter arguments for data source queries without pagination.
+ * Used internally to filter data by symbol and time range.
+ */
+interface IOptimizerFilterArgs {
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     */
+    symbol: string;
+    /**
+     * Start date of the data range (inclusive).
+     */
+    startDate: Date;
+    /**
+     * End date of the data range (inclusive).
+     */
+    endDate: Date;
+}
+/**
+ * Fetch arguments for paginated data source queries.
+ * Extends filter arguments with pagination parameters.
+ */
+interface IOptimizerFetchArgs extends IOptimizerFilterArgs {
+    /**
+     * Maximum number of records to fetch per request.
+     * Default: 25 (ITERATION_LIMIT)
+     */
+    limit: number;
+    /**
+     * Number of records to skip from the beginning.
+     * Used for pagination (offset = page * limit).
+     */
+    offset: number;
+}
+/**
+ * Data source function for fetching optimizer training data.
+ * Must support pagination and return data with unique IDs.
+ *
+ * @param args - Fetch arguments including symbol, dates, limit, offset
+ * @returns Array of data rows or Promise resolving to data array
+ */
+interface IOptimizerSourceFn<Data extends IOptimizerData = any> {
+    (args: IOptimizerFetchArgs): Data[] | Promise<Data[]>;
+}
+/**
+ * Generated strategy data with LLM conversation history.
+ * Contains the full context used to generate a trading strategy.
+ */
+interface IOptimizerStrategy {
+    /**
+     * Trading pair symbol this strategy was generated for.
+     */
+    symbol: string;
+    /**
+     * Unique name taken from data source.
+     * Used in callbacks and logging.
+     */
+    name: string;
+    /**
+     * LLM conversation history used to generate the strategy.
+     * Contains user prompts and assistant responses for each data source.
+     */
+    messages: MessageModel[];
+    /**
+     * Generated strategy prompt/description.
+     * Output from getPrompt() function, used as strategy logic.
+     */
+    strategy: string;
+}
+/**
+ * Data source configuration with custom message formatters.
+ * Defines how to fetch data and format it for LLM conversation.
+ */
+interface IOptimizerSource<Data extends IOptimizerData = any> {
+    /**
+     * Optional description of this data source.
+     * Example: "Historical backtest results for training"
+     */
+    note?: string;
+    /**
+     * Unique name identifying this data source.
+     * Used in callbacks and logging.
+     */
+    name: string;
+    /**
+     * Function to fetch data from this source.
+     * Must support pagination via limit/offset.
+     */
+    fetch: IOptimizerSourceFn<Data>;
+    /**
+     * Optional custom formatter for user messages.
+     * If not provided, uses default template from OptimizerTemplateService.
+     *
+     * @param symbol - Trading pair symbol
+     * @param data - Fetched data array
+     * @param name - Source name
+     * @returns Formatted user message content
+     */
+    user?: (symbol: string, data: Data[], name: string) => string | Promise<string>;
+    /**
+     * Optional custom formatter for assistant messages.
+     * If not provided, uses default template from OptimizerTemplateService.
+     *
+     * @param symbol - Trading pair symbol
+     * @param data - Fetched data array
+     * @param name - Source name
+     * @returns Formatted assistant message content
+     */
+    assistant?: (symbol: string, data: Data[], name: string) => string | Promise<string>;
+}
+/**
+ * Union type for data source configuration.
+ * Can be either a simple fetch function or a full source configuration object.
+ */
+type Source<Data extends IOptimizerData = any> = IOptimizerSourceFn<Data> | IOptimizerSource<Data>;
+/**
+ * Lifecycle callbacks for optimizer events.
+ * Provides hooks for monitoring and validating optimizer operations.
+ */
+interface IOptimizerCallbacks {
+    /**
+     * Called after strategy data is generated for all train ranges.
+     * Useful for logging or validating the generated strategies.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyData - Array of generated strategies with their messages
+     */
+    onData?: (symbol: string, strategyData: IOptimizerStrategy[]) => void | Promise<void>;
+    /**
+     * Called after strategy code is generated.
+     * Useful for logging or validating the generated code.
+     *
+     * @param symbol - Trading pair symbol
+     * @param code - Generated strategy code
+     */
+    onCode?: (symbol: string, code: string) => void | Promise<void>;
+    /**
+     * Called after strategy code is dumped to file.
+     * Useful for logging or performing additional actions after file write.
+     *
+     * @param symbol - Trading pair symbol
+     * @param filepath - Path where the file was saved
+     */
+    onDump?: (symbol: string, filepath: string) => void | Promise<void>;
+    /**
+     * Called after data is fetched from a source.
+     * Useful for logging or validating the fetched data.
+     *
+     * @param symbol - Trading pair symbol
+     * @param sourceName - Name of the data source
+     * @param data - Array of fetched data
+     * @param startDate - Start date of the data range
+     * @param endDate - End date of the data range
+     */
+    onSourceData?: <Data extends IOptimizerData = any>(symbol: string, sourceName: string, data: Data[], startDate: Date, endDate: Date) => void | Promise<void>;
+}
+/**
+ * Template interface for generating code snippets and LLM messages.
+ * Each method returns TypeScript/JavaScript code as a string.
+ */
+interface IOptimizerTemplate {
+    /**
+     * Generates the top banner with imports and initialization.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Generated import statements and setup code
+     */
+    getTopBanner(symbol: string): string | Promise<string>;
+    /**
+     * Generates default user message content for LLM conversation.
+     *
+     * @param symbol - Trading pair symbol
+     * @param data - Data array from source
+     * @param name - Source name
+     * @returns Formatted user message content
+     */
+    getUserMessage<Data extends IOptimizerData = any>(symbol: string, data: Data[], name: string): string | Promise<string>;
+    /**
+     * Generates default assistant message content for LLM conversation.
+     *
+     * @param symbol - Trading pair symbol
+     * @param data - Data array from source
+     * @param name - Source name
+     * @returns Formatted assistant message content
+     */
+    getAssistantMessage<Data extends IOptimizerData = any>(symbol: string, data: Data[], name: string): string | Promise<string>;
+    /**
+     * Generates Walker configuration code.
+     *
+     * @param walkerName - Unique walker identifier
+     * @param exchangeName - Exchange name to use
+     * @param frameName - Frame name for testing
+     * @param strategies - Array of strategy names to compare
+     * @returns Generated addWalker() call
+     */
+    getWalkerTemplate(walkerName: string, exchangeName: string, frameName: string, strategies: string[]): string | Promise<string>;
+    /**
+     * Generates Exchange configuration code.
+     *
+     * @param symbol - Trading pair symbol
+     * @param exchangeName - Unique exchange identifier
+     * @returns Generated addExchange() call with CCXT integration
+     */
+    getExchangeTemplate(symbol: string, exchangeName: string): string | Promise<string>;
+    /**
+     * Generates Frame (timeframe) configuration code.
+     *
+     * @param symbol - Trading pair symbol
+     * @param frameName - Unique frame identifier
+     * @param interval - Candle interval (e.g., "1m", "5m")
+     * @param startDate - Frame start date
+     * @param endDate - Frame end date
+     * @returns Generated addFrame() call
+     */
+    getFrameTemplate(symbol: string, frameName: string, interval: CandleInterval, startDate: Date, endDate: Date): string | Promise<string>;
+    /**
+     * Generates Strategy configuration code with LLM integration.
+     *
+     * @param strategyName - Unique strategy identifier
+     * @param interval - Signal throttling interval (e.g., "5m")
+     * @param prompt - Strategy logic prompt from getPrompt()
+     * @returns Generated addStrategy() call with getSignal() function
+     */
+    getStrategyTemplate(strategyName: string, interval: string, prompt: string): string | Promise<string>;
+    /**
+     * Generates launcher code to run Walker and listen to events.
+     *
+     * @param symbol - Trading pair symbol
+     * @param walkerName - Walker name to launch
+     * @returns Generated Walker.background() call with event listeners
+     */
+    getLauncherTemplate(symbol: string, walkerName: string): string | Promise<string>;
+    /**
+     * Generates text() helper function for LLM text generation.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Generated async text() function using Ollama
+     */
+    getTextTemplate(symbol: string): string | Promise<string>;
+    /**
+     * Generates json() helper function for structured LLM output.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Generated async json() function with signal schema
+     */
+    getJsonTemplate(symbol: string): string | Promise<string>;
+    /**
+     * Generates dumpJson() helper function for debug output.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Generated async dumpJson() function for file logging
+     */
+    getJsonDumpTemplate: (symbol: string) => string | Promise<string>;
+}
+/**
+ * Schema configuration for optimizer registration.
+ * Defines how to collect data, generate strategies, and create executable code.
+ */
+interface IOptimizerSchema {
+    /**
+     * Optional description of this optimizer configuration.
+     */
+    note?: string;
+    /**
+     * Unique identifier for this optimizer.
+     * Used to retrieve optimizer instance from registry.
+     */
+    optimizerName: OptimizerName;
+    /**
+     * Array of training time ranges.
+     * Each range generates a separate strategy variant for comparison.
+     */
+    rangeTrain: IOptimizerRange[];
+    /**
+     * Testing time range for strategy validation.
+     * Used in generated Walker to evaluate strategy performance.
+     */
+    rangeTest: IOptimizerRange;
+    /**
+     * Array of data sources for strategy generation.
+     * Each source contributes to the LLM conversation context.
+     */
+    source: Source[];
+    /**
+     * Function to generate strategy prompt from conversation history.
+     * Called after all sources are processed for each training range.
+     *
+     * @param symbol - Trading pair symbol
+     * @param messages - Complete conversation history with all sources
+     * @returns Strategy prompt/logic description
+     */
+    getPrompt: (symbol: string, messages: MessageModel[]) => string | Promise<string>;
+    /**
+     * Optional custom template overrides.
+     * If not provided, uses defaults from OptimizerTemplateService.
+     */
+    template?: Partial<IOptimizerTemplate>;
+    /**
+     * Optional lifecycle callbacks for monitoring.
+     */
+    callbacks?: Partial<IOptimizerCallbacks>;
+}
+/**
+ * Internal parameters for ClientOptimizer instantiation.
+ * Extends schema with resolved dependencies (logger, complete template).
+ */
+interface IOptimizerParams extends IOptimizerSchema {
+    /**
+     * Logger instance for debug and info messages.
+     * Injected by OptimizerConnectionService.
+     */
+    logger: ILogger;
+    /**
+     * Complete template implementation with all methods.
+     * Merged from schema.template and OptimizerTemplateService defaults.
+     */
+    template: IOptimizerTemplate;
+}
+/**
+ * Optimizer client interface for strategy generation and code export.
+ * Implemented by ClientOptimizer class.
+ */
+interface IOptimizer {
+    /**
+     * 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
+     */
+    getData(symbol: string): Promise<IOptimizerStrategy[]>;
+    /**
+     * Generates complete executable strategy code.
+     * Includes imports, helpers, strategies, walker, and launcher.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Generated TypeScript/JavaScript code as string
+     */
+    getCode(symbol: string): Promise<string>;
+    /**
+     * 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: "./")
+     */
+    dump(symbol: string, path?: string): Promise<void>;
+}
+/**
+ * Unique string identifier for registered optimizers.
+ */
+type OptimizerName = string;
+
 /**
  * Registers a trading strategy in the framework.
  *
@@ -1588,7 +2160,95 @@ declare function addSizing(sizingSchema: ISizingSchema): void;
  * ```
  */
 declare function addRisk(riskSchema: IRiskSchema): void;
-
+/**
+ * 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}`);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function addOptimizer(optimizerSchema: IOptimizerSchema): void;
+
 /**
  * Returns a list of all registered exchange schemas.
  *
@@ -1768,6 +2428,43 @@ declare function listSizings(): Promise<ISizingSchema[]>;
  * ```
  */
 declare function listRisks(): Promise<IRiskSchema[]>;
+/**
+ * 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...", ... }]
+ * ```
+ */
+declare function listOptimizers(): Promise<IOptimizerSchema[]>;
 
 /**
  * Contract for background execution completion events.
@@ -1807,15 +2504,15 @@ interface DoneContract {
  *
  * @example
  * ```typescript
- * import { listenProgress } from "backtest-kit";
+ * import { listenBacktestProgress } from "backtest-kit";
  *
- * listenProgress((event) => {
+ * listenBacktestProgress((event) => {
  *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
  *   console.log(`Processed: ${event.processedFrames} / ${event.totalFrames}`);
  * });
  * ```
  */
-interface ProgressContract {
+interface ProgressBacktestContract {
     /** exchangeName - Name of the exchange used in execution */
     exchangeName: string;
     /** strategyName - Name of the strategy being executed */
@@ -1830,6 +2527,39 @@ interface ProgressContract {
     progress: number;
 }
 
+/**
+ * Contract for walker progress events.
+ *
+ * Emitted during Walker.background() execution to track progress.
+ * Contains information about total strategies, processed strategies, and completion percentage.
+ *
+ * @example
+ * ```typescript
+ * import { listenWalkerProgress } from "backtest-kit";
+ *
+ * listenWalkerProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`Processed: ${event.processedStrategies} / ${event.totalStrategies}`);
+ * });
+ * ```
+ */
+interface ProgressWalkerContract {
+    /** walkerName - Name of the walker being executed */
+    walkerName: string;
+    /** exchangeName - Name of the exchange used in execution */
+    exchangeName: string;
+    /** frameName - Name of the frame being used */
+    frameName: string;
+    /** symbol - Trading symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** totalStrategies - Total number of strategies to process */
+    totalStrategies: number;
+    /** processedStrategies - Number of strategies processed so far */
+    processedStrategies: number;
+    /** progress - Completion percentage from 0.0 to 1.0 */
+    progress: number;
+}
+
 /**
  * Performance metric types tracked by the system.
  *
@@ -1908,6 +2638,180 @@ interface WalkerContract {
     totalStrategies: number;
 }
 
+/**
+ * Contract for partial profit level events.
+ *
+ * Emitted by partialProfitSubject when a signal reaches a profit level milestone (10%, 20%, 30%, etc).
+ * Used for tracking partial take-profit execution and monitoring strategy performance.
+ *
+ * Events are emitted only once per level per signal (Set-based deduplication in ClientPartial).
+ * Multiple levels can be emitted in a single tick if price jumps significantly.
+ *
+ * Consumers:
+ * - PartialMarkdownService: Accumulates events for report generation
+ * - User callbacks via listenPartialProfit() / listenPartialProfitOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenPartialProfit } from "backtest-kit";
+ *
+ * // Listen to all partial profit events
+ * listenPartialProfit((event) => {
+ *   console.log(`[${event.backtest ? "Backtest" : "Live"}] Signal ${event.data.id} reached ${event.level}% profit`);
+ *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
+ *   console.log(`Position: ${event.data.position}, Entry: ${event.data.priceOpen}`);
+ * });
+ *
+ * // Wait for first 50% profit level
+ * listenPartialProfitOnce(
+ *   (event) => event.level === 50,
+ *   (event) => console.log("50% profit reached:", event.data.id)
+ * );
+ * ```
+ */
+interface PartialProfitContract {
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this profit event belongs to.
+     */
+    symbol: string;
+    /**
+     * Complete signal row data.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
+     */
+    data: ISignalRow;
+    /**
+     * Current market price at which this profit level was reached.
+     * Used to calculate actual profit percentage.
+     */
+    currentPrice: number;
+    /**
+     * Profit level milestone reached (10, 20, 30, 40, 50, 60, 70, 80, 90, or 100).
+     * Represents percentage profit relative to entry price.
+     *
+     * @example
+     * ```typescript
+     * // If entry was $50000 and level is 20:
+     * // currentPrice >= $60000 (20% profit)
+     * ```
+     */
+    level: PartialLevel;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment profit level was detected
+     * - Backtest mode: candle.timestamp of the candle that triggered the level
+     *
+     * @example
+     * ```typescript
+     * const eventDate = new Date(event.timestamp);
+     * console.log(`Profit reached at: ${eventDate.toISOString()}`);
+     * ```
+     */
+    timestamp: number;
+}
+
+/**
+ * Contract for partial loss level events.
+ *
+ * Emitted by partialLossSubject when a signal reaches a loss level milestone (-10%, -20%, -30%, etc).
+ * Used for tracking partial stop-loss execution and monitoring strategy drawdown.
+ *
+ * Events are emitted only once per level per signal (Set-based deduplication in ClientPartial).
+ * Multiple levels can be emitted in a single tick if price drops significantly.
+ *
+ * Consumers:
+ * - PartialMarkdownService: Accumulates events for report generation
+ * - User callbacks via listenPartialLoss() / listenPartialLossOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenPartialLoss } from "backtest-kit";
+ *
+ * // Listen to all partial loss events
+ * listenPartialLoss((event) => {
+ *   console.log(`[${event.backtest ? "Backtest" : "Live"}] Signal ${event.data.id} reached -${event.level}% loss`);
+ *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
+ *   console.log(`Position: ${event.data.position}, Entry: ${event.data.priceOpen}`);
+ *
+ *   // Alert on significant loss
+ *   if (event.level >= 30 && !event.backtest) {
+ *     console.warn("HIGH LOSS ALERT:", event.data.id);
+ *   }
+ * });
+ *
+ * // Wait for first 20% loss level
+ * listenPartialLossOnce(
+ *   (event) => event.level === 20,
+ *   (event) => console.log("20% loss reached:", event.data.id)
+ * );
+ * ```
+ */
+interface PartialLossContract {
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this loss event belongs to.
+     */
+    symbol: string;
+    /**
+     * Complete signal row data.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
+     */
+    data: ISignalRow;
+    /**
+     * Current market price at which this loss level was reached.
+     * Used to calculate actual loss percentage.
+     */
+    currentPrice: number;
+    /**
+     * Loss level milestone reached (10, 20, 30, 40, 50, 60, 70, 80, 90, or 100).
+     * Represents percentage loss relative to entry price (absolute value).
+     *
+     * Note: Stored as positive number, but represents negative loss.
+     * level=20 means -20% loss from entry price.
+     *
+     * @example
+     * ```typescript
+     * // If entry was $50000 and level is 20:
+     * // currentPrice <= $40000 (-20% loss)
+     * // Level is stored as 20, not -20
+     * ```
+     */
+    level: PartialLevel;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment loss level was detected
+     * - Backtest mode: candle.timestamp of the candle that triggered the level
+     *
+     * @example
+     * ```typescript
+     * const eventDate = new Date(event.timestamp);
+     * console.log(`Loss reached at: ${eventDate.toISOString()}`);
+     *
+     * // Calculate time in loss
+     * const entryTime = event.data.pendingAt;
+     * const timeInLoss = event.timestamp - entryTime;
+     * console.log(`In loss for ${timeInLoss / 1000 / 60} minutes`);
+     * ```
+     */
+    timestamp: number;
+}
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -2254,9 +3158,9 @@ declare function listenDoneWalkerOnce(filterFn: (event: DoneContract) => boolean
  *
  * @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}`);
@@ -2272,7 +3176,38 @@ declare function listenDoneWalkerOnce(filterFn: (event: DoneContract) => boolean
  * unsubscribe();
  * ```
  */
-declare function listenProgress(fn: (event: ProgressContract) => void): () => void;
+declare function listenBacktestProgress(fn: (event: ProgressBacktestContract) => void): () => void;
+/**
+ * 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();
+ * ```
+ */
+declare function listenWalkerProgress(fn: (event: ProgressWalkerContract) => void): () => void;
 /**
  * Subscribes to performance metric events with queued async processing.
  *
@@ -2434,6 +3369,118 @@ declare function listenWalkerComplete(fn: (event: IWalkerResults) => void): () =
  * ```
  */
 declare function listenValidation(fn: (error: Error) => void): () => void;
+/**
+ * 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();
+ * ```
+ */
+declare function listenPartialProfit(fn: (event: PartialProfitContract) => void): () => void;
+/**
+ * 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();
+ * ```
+ */
+declare function listenPartialProfitOnce(filterFn: (event: PartialProfitContract) => boolean, fn: (event: PartialProfitContract) => void): () => void;
+/**
+ * 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();
+ * ```
+ */
+declare function listenPartialLoss(fn: (event: PartialLossContract) => void): () => void;
+/**
+ * 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();
+ * ```
+ */
+declare function listenPartialLossOnce(filterFn: (event: PartialLossContract) => boolean, fn: (event: PartialLossContract) => void): () => void;
 
 /**
  * Fetches historical candle data from the registered exchange.
@@ -2770,13 +3817,13 @@ declare 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
@@ -2963,13 +4010,13 @@ declare 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
@@ -3134,7 +4181,7 @@ declare 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
@@ -3184,116 +4231,300 @@ declare class WalkerMarkdownService {
      * Memoized function to get or create ReportStorage for a walker.
      * Each walker gets its own isolated storage instance.
      */
-    private getStorage;
+    private getStorage;
+    /**
+     * Processes walker progress events and accumulates strategy results.
+     * Should be called from walkerEmitter.
+     *
+     * @param data - Walker contract from walker execution
+     *
+     * @example
+     * ```typescript
+     * const service = new WalkerMarkdownService();
+     * walkerEmitter.subscribe((data) => service.tick(data));
+     * ```
+     */
+    private tick;
+    /**
+     * Gets walker results data from all strategy results.
+     * Delegates to ReportStorage.getData().
+     *
+     * @param walkerName - Walker name to get data for
+     * @param symbol - Trading symbol
+     * @param metric - Metric being optimized
+     * @param context - Context with exchangeName and frameName
+     * @returns Walker results data object with all metrics
+     *
+     * @example
+     * ```typescript
+     * const service = new WalkerMarkdownService();
+     * const results = await service.getData("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+     * console.log(results.bestStrategy, results.bestMetric);
+     * ```
+     */
+    getData: (walkerName: WalkerName, symbol: string, metric: WalkerMetric, context: {
+        exchangeName: string;
+        frameName: string;
+    }) => Promise<IWalkerResults>;
+    /**
+     * Generates markdown report with all strategy results for a walker.
+     * Delegates to ReportStorage.getReport().
+     *
+     * @param walkerName - Walker name to generate report for
+     * @param symbol - Trading symbol
+     * @param metric - Metric being optimized
+     * @param context - Context with exchangeName and frameName
+     * @returns Markdown formatted report string
+     *
+     * @example
+     * ```typescript
+     * const service = new WalkerMarkdownService();
+     * const markdown = await service.getReport("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+     * console.log(markdown);
+     * ```
+     */
+    getReport: (walkerName: WalkerName, symbol: string, metric: WalkerMetric, context: {
+        exchangeName: string;
+        frameName: string;
+    }) => Promise<string>;
+    /**
+     * Saves walker report to disk.
+     * Creates directory if it doesn't exist.
+     * Delegates to ReportStorage.dump().
+     *
+     * @param walkerName - Walker name to save report for
+     * @param symbol - Trading symbol
+     * @param metric - Metric being optimized
+     * @param context - Context with exchangeName and frameName
+     * @param path - Directory path to save report (default: "./dump/walker")
+     *
+     * @example
+     * ```typescript
+     * const service = new WalkerMarkdownService();
+     *
+     * // 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");
+     * ```
+     */
+    dump: (walkerName: WalkerName, symbol: string, metric: WalkerMetric, context: {
+        exchangeName: string;
+        frameName: string;
+    }, path?: string) => Promise<void>;
+    /**
+     * Clears accumulated result data from storage.
+     * If walkerName is provided, clears only that walker's data.
+     * If walkerName is omitted, clears all walkers' data.
+     *
+     * @param walkerName - Optional walker name to clear specific walker data
+     *
+     * @example
+     * ```typescript
+     * const service = new WalkerMarkdownService();
+     *
+     * // Clear specific walker data
+     * await service.clear("my-walker");
+     *
+     * // Clear all walkers' data
+     * await service.clear();
+     * ```
+     */
+    clear: (walkerName?: WalkerName) => Promise<void>;
+    /**
+     * Initializes the service by subscribing to walker events.
+     * Uses singleshot to ensure initialization happens only once.
+     * Automatically called on first use.
+     *
+     * @example
+     * ```typescript
+     * const service = new WalkerMarkdownService();
+     * await service.init(); // Subscribe to walker events
+     * ```
+     */
+    protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+/**
+ * Unified partial profit/loss event data for report generation.
+ * Contains all information about profit and loss level milestones.
+ */
+interface PartialEvent {
+    /** Event timestamp in milliseconds */
+    timestamp: number;
+    /** Event action type (profit or loss) */
+    action: "profit" | "loss";
+    /** Trading pair symbol */
+    symbol: string;
+    /** Signal ID */
+    signalId: string;
+    /** Position type */
+    position: string;
+    /** Current market price */
+    currentPrice: number;
+    /** Profit/loss level reached (10, 20, 30, etc) */
+    level: PartialLevel;
+    /** True if backtest mode, false if live mode */
+    backtest: boolean;
+}
+/**
+ * Statistical data calculated from partial profit/loss events.
+ *
+ * Provides metrics for partial profit/loss milestone tracking.
+ *
+ * @example
+ * ```typescript
+ * const stats = await Partial.getData("my-strategy");
+ *
+ * console.log(`Total events: ${stats.totalEvents}`);
+ * console.log(`Profit events: ${stats.totalProfit}`);
+ * console.log(`Loss events: ${stats.totalLoss}`);
+ * ```
+ */
+interface PartialStatistics {
+    /** Array of all profit/loss events with full details */
+    eventList: PartialEvent[];
+    /** Total number of all events (includes profit, loss) */
+    totalEvents: number;
+    /** Total number of profit events */
+    totalProfit: number;
+    /** Total number of loss events */
+    totalLoss: number;
+}
+/**
+ * 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");
+ * ```
+ */
+declare class PartialMarkdownService {
+    /** Logger service for debug output */
+    private readonly loggerService;
+    /**
+     * Memoized function to get or create ReportStorage for a symbol.
+     * Each symbol gets its own isolated storage instance.
+     */
+    private getStorage;
+    /**
+     * 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()
+     * ```
+     */
+    private tickProfit;
     /**
-     * Processes walker progress events and accumulates strategy results.
-     * Should be called from walkerEmitter.
+     * Processes loss events and accumulates them.
+     * Should be called from partialLossSubject subscription.
      *
-     * @param data - Walker contract from walker execution
+     * @param data - Loss event data
      *
      * @example
      * ```typescript
-     * const service = new WalkerMarkdownService();
-     * walkerEmitter.subscribe((data) => service.tick(data));
+     * const service = new PartialMarkdownService();
+     * // Service automatically subscribes in init()
      * ```
      */
-    private tick;
+    private tickLoss;
     /**
-     * Gets walker results data from all strategy results.
+     * Gets statistical data from all partial profit/loss events for a symbol.
      * Delegates to ReportStorage.getData().
      *
-     * @param walkerName - Walker name to get data for
-     * @param symbol - Trading symbol
-     * @param metric - Metric being optimized
-     * @param context - Context with exchangeName and frameName
-     * @returns Walker results data object with all metrics
+     * @param symbol - Trading pair symbol to get data for
+     * @returns Statistical data object with all metrics
      *
      * @example
      * ```typescript
-     * const service = new WalkerMarkdownService();
-     * const results = await service.getData("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
-     * console.log(results.bestStrategy, results.bestMetric);
+     * const service = new PartialMarkdownService();
+     * const stats = await service.getData("BTCUSDT");
+     * console.log(stats.totalProfit, stats.totalLoss);
      * ```
      */
-    getData: (walkerName: WalkerName, symbol: string, metric: WalkerMetric, context: {
-        exchangeName: string;
-        frameName: string;
-    }) => Promise<IWalkerResults>;
+    getData: (symbol: string) => Promise<PartialStatistics>;
     /**
-     * Generates markdown report with all strategy results for a walker.
+     * Generates markdown report with all partial events for a symbol.
      * Delegates to ReportStorage.getReport().
      *
-     * @param walkerName - Walker name to generate report for
-     * @param symbol - Trading symbol
-     * @param metric - Metric being optimized
-     * @param context - Context with exchangeName and frameName
-     * @returns Markdown formatted report string
+     * @param symbol - Trading pair symbol to generate report for
+     * @returns Markdown formatted report string with table of all events
      *
      * @example
      * ```typescript
-     * const service = new WalkerMarkdownService();
-     * const markdown = await service.getReport("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+     * const service = new PartialMarkdownService();
+     * const markdown = await service.getReport("BTCUSDT");
      * console.log(markdown);
      * ```
      */
-    getReport: (walkerName: WalkerName, symbol: string, metric: WalkerMetric, context: {
-        exchangeName: string;
-        frameName: string;
-    }) => Promise<string>;
+    getReport: (symbol: string) => Promise<string>;
     /**
-     * Saves walker report to disk.
+     * Saves symbol report to disk.
      * Creates directory if it doesn't exist.
      * Delegates to ReportStorage.dump().
      *
-     * @param walkerName - Walker name to save report for
-     * @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 symbol - Trading pair symbol to save report for
+     * @param path - Directory path to save report (default: "./dump/partial")
      *
      * @example
      * ```typescript
-     * const service = new WalkerMarkdownService();
+     * const service = new PartialMarkdownService();
      *
-     * // Save to default path: ./logs/walker/my-walker.md
-     * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+     * // Save to default path: ./dump/partial/BTCUSDT.md
+     * await service.dump("BTCUSDT");
      *
-     * // Save to custom path: ./custom/path/my-walker.md
-     * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" }, "./custom/path");
+     * // Save to custom path: ./custom/path/BTCUSDT.md
+     * await service.dump("BTCUSDT", "./custom/path");
      * ```
      */
-    dump: (walkerName: WalkerName, symbol: string, metric: WalkerMetric, context: {
-        exchangeName: string;
-        frameName: string;
-    }, path?: string) => Promise<void>;
+    dump: (symbol: string, path?: string) => Promise<void>;
     /**
-     * Clears accumulated result data from storage.
-     * If walkerName is provided, clears only that walker's data.
-     * If walkerName is omitted, clears all walkers' data.
+     * 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 walkerName - Optional walker name to clear specific walker data
+     * @param symbol - Optional symbol to clear specific symbol data
      *
      * @example
      * ```typescript
-     * const service = new WalkerMarkdownService();
+     * const service = new PartialMarkdownService();
      *
-     * // Clear specific walker data
-     * await service.clear("my-walker");
+     * // Clear specific symbol data
+     * await service.clear("BTCUSDT");
      *
-     * // Clear all walkers' data
+     * // Clear all symbols' data
      * await service.clear();
      * ```
      */
-    clear: (walkerName?: WalkerName) => Promise<void>;
+    clear: (symbol?: string) => Promise<void>;
     /**
-     * Initializes the service by subscribing to walker events.
+     * 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 WalkerMarkdownService();
-     * await service.init(); // Subscribe to walker events
+     * const service = new PartialMarkdownService();
+     * await service.init(); // Subscribe to profit/loss events
      * ```
      */
     protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
@@ -3600,6 +4831,154 @@ declare class PersistRiskUtils {
  * ```
  */
 declare const PersistRiskAdapter: PersistRiskUtils;
+/**
+ * Type for persisted scheduled signal data.
+ * Contains nullable scheduled signal for atomic updates.
+ */
+type ScheduleData = IScheduledSignalRow | null;
+/**
+ * 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).
+ */
+declare class PersistScheduleUtils {
+    private PersistScheduleFactory;
+    private getScheduleStorage;
+    /**
+     * 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: TPersistBaseCtor<StrategyName, ScheduleData>): void;
+    /**
+     * 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
+     */
+    readScheduleData: (strategyName: StrategyName, symbol: string) => Promise<IScheduledSignalRow | 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
+     */
+    writeScheduleData: (scheduledSignalRow: IScheduledSignalRow | null, strategyName: StrategyName, symbol: string) => Promise<void>;
+}
+/**
+ * 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");
+ * ```
+ */
+declare const PersistScheduleAdapter: PersistScheduleUtils;
+/**
+ * Type for persisted partial data.
+ * Stores profit and loss levels as arrays for JSON serialization.
+ */
+type PartialData = Record<string, IPartialData>;
+/**
+ * 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.
+ */
+declare class PersistPartialUtils {
+    private PersistPartialFactory;
+    private getPartialStorage;
+    /**
+     * 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: TPersistBaseCtor<string, PartialData>): void;
+    /**
+     * 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
+     */
+    readPartialData: (symbol: string) => Promise<PartialData>;
+    /**
+     * 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
+     */
+    writePartialData: (partialData: PartialData, symbol: string) => Promise<void>;
+}
+/**
+ * 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");
+ * ```
+ */
+declare const PersistPartialAdapter: PersistPartialUtils;
 
 /**
  * Utility class for backtest operations.
@@ -3689,11 +5068,11 @@ declare 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
@@ -3821,11 +5200,11 @@ declare 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
@@ -3907,11 +5286,11 @@ declare 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
@@ -3919,23 +5298,6 @@ declare class ScheduleUtils {
      * ```
      */
     dump: (strategyName: StrategyName, path?: string) => Promise<void>;
-    /**
-     * 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();
-     * ```
-     */
-    clear: (strategyName?: StrategyName) => Promise<void>;
 }
 /**
  * Singleton instance of ScheduleUtils for convenient scheduled signals reporting.
@@ -4037,14 +5399,14 @@ declare 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
@@ -4154,11 +5516,11 @@ declare 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
@@ -4265,11 +5627,11 @@ declare 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
@@ -4371,25 +5733,247 @@ declare class PositionSizeUtils {
      * @returns Promise resolving to calculated position size
      * @throws Error if sizing schema method is not "kelly-criterion"
      */
-    static kellyCriterion: (symbol: string, accountBalance: number, priceOpen: number, winRate: number, winLossRatio: number, context: {
-        sizingName: SizingName;
-    }) => Promise<number>;
+    static kellyCriterion: (symbol: string, accountBalance: number, priceOpen: number, winRate: number, winLossRatio: number, context: {
+        sizingName: SizingName;
+    }) => Promise<number>;
+    /**
+     * Calculates position size using ATR-based method.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param accountBalance - Current account balance
+     * @param priceOpen - Planned entry price
+     * @param atr - Current ATR value
+     * @param context - Execution context with sizing name
+     * @returns Promise resolving to calculated position size
+     * @throws Error if sizing schema method is not "atr-based"
+     */
+    static atrBased: (symbol: string, accountBalance: number, priceOpen: number, atr: number, context: {
+        sizingName: SizingName;
+    }) => Promise<number>;
+}
+declare const PositionSize: typeof PositionSizeUtils;
+
+/**
+ * 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");
+ * ```
+ */
+declare class OptimizerUtils {
+    /**
+     * 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
+     */
+    getData: (symbol: string, context: {
+        optimizerName: OptimizerName;
+    }) => Promise<IOptimizerStrategy[]>;
+    /**
+     * 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
+     */
+    getCode: (symbol: string, context: {
+        optimizerName: OptimizerName;
+    }) => Promise<string>;
+    /**
+     * 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
+     */
+    dump: (symbol: string, context: {
+        optimizerName: string;
+    }, path?: string) => Promise<void>;
+}
+/**
+ * Singleton instance of OptimizerUtils.
+ * Public API for optimizer operations.
+ *
+ * @example
+ * ```typescript
+ * import { Optimizer } from "backtest-kit";
+ *
+ * await Optimizer.dump("BTCUSDT", { optimizerName: "my-optimizer" });
+ * ```
+ */
+declare const Optimizer: OptimizerUtils;
+
+/**
+ * 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
+ * ```
+ */
+declare class PartialUtils {
+    /**
+     * 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}%`);
+     * }
+     * ```
+     */
+    getData: (symbol: string) => Promise<PartialStatistics>;
+    /**
+     * 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
+     * ```
+     */
+    getReport: (symbol: string) => Promise<string>;
     /**
-     * Calculates position size using ATR-based method.
+     * 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 accountBalance - Current account balance
-     * @param priceOpen - Planned entry price
-     * @param atr - Current ATR value
-     * @param context - Execution context with sizing name
-     * @returns Promise resolving to calculated position size
-     * @throws Error if sizing schema method is not "atr-based"
+     * @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");
+     * }
+     * ```
      */
-    static atrBased: (symbol: string, accountBalance: number, priceOpen: number, atr: number, context: {
-        sizingName: SizingName;
-    }) => Promise<number>;
+    dump: (symbol: string, path?: string) => Promise<void>;
 }
-declare const PositionSize: typeof PositionSizeUtils;
+/**
+ * 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");
+ * ```
+ */
+declare const Partial$1: PartialUtils;
 
 /**
  * Global signal emitter for all trading events (live + backtest).
@@ -4430,7 +6014,12 @@ declare const doneWalkerSubject: Subject<DoneContract>;
  * Progress emitter for backtest execution progress.
  * Emits progress updates during backtest execution.
  */
-declare const progressEmitter: Subject<ProgressContract>;
+declare const progressBacktestEmitter: Subject<ProgressBacktestContract>;
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+declare const progressWalkerEmitter: Subject<ProgressWalkerContract>;
 /**
  * Performance emitter for execution metrics.
  * Emits performance metrics for profiling and bottleneck detection.
@@ -4456,13 +6045,26 @@ declare const walkerStopSubject: Subject<string>;
  * Emits when risk validation functions throw errors during signal checking.
  */
 declare const validationSubject: Subject<Error>;
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+declare const partialProfitSubject: Subject<PartialProfitContract>;
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+declare const partialLossSubject: Subject<PartialLossContract>;
 
 declare const emitters_doneBacktestSubject: typeof doneBacktestSubject;
 declare const emitters_doneLiveSubject: typeof doneLiveSubject;
 declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
 declare const emitters_errorEmitter: typeof errorEmitter;
+declare const emitters_partialLossSubject: typeof partialLossSubject;
+declare const emitters_partialProfitSubject: typeof partialProfitSubject;
 declare const emitters_performanceEmitter: typeof performanceEmitter;
-declare const emitters_progressEmitter: typeof progressEmitter;
+declare const emitters_progressBacktestEmitter: typeof progressBacktestEmitter;
+declare const emitters_progressWalkerEmitter: typeof progressWalkerEmitter;
 declare const emitters_signalBacktestEmitter: typeof signalBacktestEmitter;
 declare const emitters_signalEmitter: typeof signalEmitter;
 declare const emitters_signalLiveEmitter: typeof signalLiveEmitter;
@@ -4471,7 +6073,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_performanceEmitter as performanceEmitter, emitters_progressEmitter as progressEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -4723,6 +6325,7 @@ declare class StrategyConnectionService implements IStrategy {
     private readonly riskConnectionService;
     private readonly exchangeConnectionService;
     private readonly methodContextService;
+    private readonly partialConnectionService;
     /**
      * Retrieves memoized ClientStrategy instance for given strategy name.
      *
@@ -6078,13 +7681,13 @@ declare 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
@@ -6355,19 +7958,549 @@ declare class RiskValidationService {
     list: () => Promise<IRiskSchema[]>;
 }
 
+/**
+ * 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.
+ */
+declare class OptimizerTemplateService implements IOptimizerTemplate {
+    private readonly loggerService;
+    /**
+     * Generates the top banner with imports and constants.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Shebang, imports, and WARN_KB constant
+     */
+    getTopBanner: (symbol: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getUserMessage: (symbol: string, data: IOptimizerData[], name: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getAssistantMessage: (symbol: string, data: IOptimizerData[], name: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getWalkerTemplate: (walkerName: string, exchangeName: string, frameName: string, strategies: string[]) => Promise<string>;
+    /**
+     * 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
+     */
+    getStrategyTemplate: (strategyName: string, interval: string, prompt: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getExchangeTemplate: (symbol: string, exchangeName: ExchangeName) => Promise<string>;
+    /**
+     * 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
+     */
+    getFrameTemplate: (symbol: string, frameName: string, interval: CandleInterval, startDate: Date, endDate: Date) => Promise<string>;
+    /**
+     * 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
+     */
+    getLauncherTemplate: (symbol: string, walkerName: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getJsonDumpTemplate: (symbol: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getTextTemplate: (symbol: string) => Promise<string>;
+    /**
+     * 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
+     */
+    getJsonTemplate: (symbol: string) => Promise<string>;
+}
+
+/**
+ * Service for managing optimizer schema registration and retrieval.
+ * Provides validation and registry management for optimizer configurations.
+ *
+ * Uses ToolRegistry for immutable schema storage.
+ */
+declare class OptimizerSchemaService {
+    readonly loggerService: LoggerService;
+    private _registry;
+    /**
+     * 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
+     */
+    register: (key: OptimizerName, value: IOptimizerSchema) => void;
+    /**
+     * Validates optimizer schema structure.
+     * Checks required fields: optimizerName, rangeTrain, source, getPrompt.
+     *
+     * @param optimizerSchema - Schema to validate
+     * @throws Error if validation fails
+     */
+    private validateShallow;
+    /**
+     * 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
+     */
+    override: (key: OptimizerName, value: Partial<IOptimizerSchema>) => IOptimizerSchema;
+    /**
+     * Retrieves optimizer schema by name.
+     *
+     * @param key - Optimizer name
+     * @returns Complete optimizer schema
+     * @throws Error if optimizer not found
+     */
+    get: (key: OptimizerName) => IOptimizerSchema;
+}
+
+/**
+ * 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.
+ */
+declare class OptimizerValidationService {
+    private readonly loggerService;
+    private _optimizerMap;
+    /**
+     * 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
+     */
+    addOptimizer: (optimizerName: OptimizerName, optimizerSchema: IOptimizerSchema) => void;
+    /**
+     * 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
+     */
+    validate: (optimizerName: OptimizerName, source: string) => void;
+    /**
+     * Lists all registered optimizer schemas.
+     *
+     * @returns Array of all optimizer schemas
+     */
+    list: () => Promise<IOptimizerSchema[]>;
+}
+
+/**
+ * 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.
+ */
+declare class ClientOptimizer implements IOptimizer {
+    readonly params: IOptimizerParams;
+    constructor(params: IOptimizerParams);
+    /**
+     * 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
+     */
+    getData: (symbol: string) => Promise<IOptimizerStrategy[]>;
+    /**
+     * Generates complete executable strategy code.
+     * Includes imports, helpers, strategies, walker, and launcher.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Generated TypeScript/JavaScript code as string
+     */
+    getCode: (symbol: string) => Promise<string>;
+    /**
+     * 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: "./")
+     */
+    dump: (symbol: string, path?: string) => Promise<void>;
+}
+
+/**
+ * Type helper for optimizer method signatures.
+ * Maps IOptimizer interface methods to any return type.
+ */
+type TOptimizer = {
+    [key in keyof IOptimizer]: any;
+};
+/**
+ * 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
+ */
+declare class OptimizerConnectionService implements TOptimizer {
+    private readonly loggerService;
+    private readonly optimizerSchemaService;
+    private readonly 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
+     */
+    getOptimizer: ((optimizerName: OptimizerName) => ClientOptimizer) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientOptimizer>;
+    /**
+     * 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
+     */
+    getData: (symbol: string, optimizerName: string) => Promise<IOptimizerStrategy[]>;
+    /**
+     * Generates complete executable strategy code.
+     *
+     * @param symbol - Trading pair symbol
+     * @param optimizerName - Optimizer identifier
+     * @returns Generated TypeScript/JavaScript code as string
+     */
+    getCode: (symbol: string, optimizerName: string) => Promise<string>;
+    /**
+     * Generates and saves strategy code to file.
+     *
+     * @param symbol - Trading pair symbol
+     * @param optimizerName - Optimizer identifier
+     * @param path - Output directory path (optional)
+     */
+    dump: (symbol: string, optimizerName: string, path?: string) => Promise<void>;
+}
+
+/**
+ * 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
+ */
+declare class OptimizerGlobalService {
+    private readonly loggerService;
+    private readonly optimizerConnectionService;
+    private readonly 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
+     */
+    getData: (symbol: string, optimizerName: string) => Promise<IOptimizerStrategy[]>;
+    /**
+     * 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
+     */
+    getCode: (symbol: string, optimizerName: string) => Promise<string>;
+    /**
+     * 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
+     */
+    dump: (symbol: string, optimizerName: string, path?: string) => Promise<void>;
+}
+
+/**
+ * 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
+ * ```
+ */
+declare class PartialConnectionService implements IPartial {
+    /**
+     * Logger service injected from DI container.
+     */
+    private readonly 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
+     */
+    private getPartial;
+    /**
+     * 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
+     */
+    profit: (symbol: string, data: ISignalRow, currentPrice: number, revenuePercent: number, backtest: boolean, when: Date) => Promise<void>;
+    /**
+     * 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
+     */
+    loss: (symbol: string, data: ISignalRow, currentPrice: number, lossPercent: number, backtest: boolean, when: Date) => Promise<void>;
+    /**
+     * 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
+     */
+    clear: (symbol: string, data: ISignalRow, priceClose: number) => Promise<void>;
+}
+
+/**
+ * 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
+ * ```
+ */
+declare class PartialGlobalService {
+    /**
+     * Logger service injected from DI container.
+     * Used for logging operations at global service level.
+     */
+    private readonly loggerService;
+    /**
+     * Connection service injected from DI container.
+     * Handles actual ClientPartial instance creation and management.
+     */
+    private readonly 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
+     */
+    profit: (symbol: string, data: ISignalRow, currentPrice: number, revenuePercent: number, backtest: boolean, when: Date) => Promise<void>;
+    /**
+     * 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
+     */
+    loss: (symbol: string, data: ISignalRow, currentPrice: number, lossPercent: number, backtest: boolean, when: Date) => Promise<void>;
+    /**
+     * 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
+     */
+    clear: (symbol: string, data: ISignalRow, priceClose: number) => Promise<void>;
+}
+
 declare const backtest: {
+    optimizerTemplateService: OptimizerTemplateService;
     exchangeValidationService: ExchangeValidationService;
     strategyValidationService: StrategyValidationService;
     frameValidationService: FrameValidationService;
     walkerValidationService: WalkerValidationService;
     sizingValidationService: SizingValidationService;
     riskValidationService: RiskValidationService;
+    optimizerValidationService: OptimizerValidationService;
     backtestMarkdownService: BacktestMarkdownService;
     liveMarkdownService: LiveMarkdownService;
     scheduleMarkdownService: ScheduleMarkdownService;
     performanceMarkdownService: PerformanceMarkdownService;
     walkerMarkdownService: WalkerMarkdownService;
     heatMarkdownService: HeatMarkdownService;
+    partialMarkdownService: PartialMarkdownService;
     backtestLogicPublicService: BacktestLogicPublicService;
     liveLogicPublicService: LiveLogicPublicService;
     walkerLogicPublicService: WalkerLogicPublicService;
@@ -6382,17 +8515,22 @@ declare const backtest: {
     frameGlobalService: FrameGlobalService;
     sizingGlobalService: SizingGlobalService;
     riskGlobalService: RiskGlobalService;
+    optimizerGlobalService: OptimizerGlobalService;
+    partialGlobalService: PartialGlobalService;
     exchangeSchemaService: ExchangeSchemaService;
     strategySchemaService: StrategySchemaService;
     frameSchemaService: FrameSchemaService;
     walkerSchemaService: WalkerSchemaService;
     sizingSchemaService: SizingSchemaService;
     riskSchemaService: RiskSchemaService;
+    optimizerSchemaService: OptimizerSchemaService;
     exchangeConnectionService: ExchangeConnectionService;
     strategyConnectionService: StrategyConnectionService;
     frameConnectionService: FrameConnectionService;
     sizingConnectionService: SizingConnectionService;
     riskConnectionService: RiskConnectionService;
+    optimizerConnectionService: OptimizerConnectionService;
+    partialConnectionService: PartialConnectionService;
     executionContextService: {
         readonly context: IExecutionContext;
     };
@@ -6402,4 +8540,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { Backtest, type BacktestStatistics, type CandleInterval, type DoneContract, type EntityId, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IHeatmapStatistics, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, Live, type LiveStatistics, MethodContextService, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatistics, PersistBase, PersistRiskAdapter, PersistSignalAdapter, PositionSize, type ProgressContract, type RiskData, Schedule, type ScheduleStatistics, type SignalData, type SignalInterval, type TPersistBase, type TPersistBaseCtor, Walker, type WalkerMetric, type WalkerStatistics, addExchange, addFrame, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listRisks, listSizings, listStrategies, listWalkers, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPerformance, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, setConfig, setLogger };
+export { Backtest, type BacktestStatistics, type CandleInterval, type DoneContract, type EntityId, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IHeatmapStatistics, type IOptimizerCallbacks, type IOptimizerData, type IOptimizerFetchArgs, type IOptimizerFilterArgs, type IOptimizerRange, type IOptimizerSchema, type IOptimizerSource, type IOptimizerStrategy, type IOptimizerTemplate, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, Live, type LiveStatistics, type MessageModel, type MessageRole, MethodContextService, Optimizer, Partial$1 as Partial, type PartialData, type PartialLossContract, type PartialProfitContract, type PartialStatistics, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatistics, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, type RiskData, Schedule, type ScheduleData, type ScheduleStatistics, type SignalData, type SignalInterval, type TPersistBase, type TPersistBaseCtor, Walker, type WalkerContract, type WalkerMetric, type WalkerStatistics, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };