backtest-kit 1.1.4 → 1.1.6

package/types.d.ts

@@ -140,6 +140,8 @@ interface IExchangeCallbacks {
 interface IExchangeSchema {
     /** Unique exchange identifier for registration */
     exchangeName: ExchangeName;
+    /** Optional developer note for documentation */
+    note?: string;
     /**
      * Fetch candles from data source (API or database).
      *
@@ -278,6 +280,8 @@ interface IFrameCallbacks {
 interface IFrameSchema {
     /** Unique identifier for this frame */
     frameName: FrameName;
+    /** Optional developer note for documentation */
+    note?: string;
     /** Interval for timestamp generation */
     interval: FrameInterval;
     /** Start of backtest period (inclusive) */
@@ -413,6 +417,8 @@ interface IStrategyCallbacks {
 interface IStrategySchema {
     /** Unique strategy identifier for registration */
     strategyName: StrategyName;
+    /** Optional developer note for documentation */
+    note?: string;
     /** Minimum interval between getSignal calls (throttling) */
     interval: SignalInterval;
     /** Signal generation function (returns null if no signal, validated DTO if signal) */
@@ -666,6 +672,90 @@ declare function addExchange(exchangeSchema: IExchangeSchema): void;
  */
 declare function addFrame(frameSchema: IFrameSchema): void;
 
+/**
+ * Returns a list of all registered exchange schemas.
+ *
+ * Retrieves all exchanges that have been registered via addExchange().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of exchange schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listExchanges, addExchange } from "backtest-kit";
+ *
+ * addExchange({
+ *   exchangeName: "binance",
+ *   note: "Binance cryptocurrency exchange",
+ *   getCandles: async (symbol, interval, since, limit) => [...],
+ *   formatPrice: async (symbol, price) => price.toFixed(2),
+ *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
+ * });
+ *
+ * const exchanges = listExchanges();
+ * console.log(exchanges);
+ * // [{ exchangeName: "binance", note: "Binance cryptocurrency exchange", ... }]
+ * ```
+ */
+declare function listExchanges(): Promise<IExchangeSchema[]>;
+/**
+ * Returns a list of all registered strategy schemas.
+ *
+ * Retrieves all strategies that have been registered via addStrategy().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of strategy schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listStrategies, addStrategy } from "backtest-kit";
+ *
+ * addStrategy({
+ *   strategyName: "my-strategy",
+ *   note: "Simple moving average crossover strategy",
+ *   interval: "5m",
+ *   getSignal: async (symbol) => ({
+ *     position: "long",
+ *     priceOpen: 50000,
+ *     priceTakeProfit: 51000,
+ *     priceStopLoss: 49000,
+ *     minuteEstimatedTime: 60,
+ *   }),
+ * });
+ *
+ * const strategies = listStrategies();
+ * console.log(strategies);
+ * // [{ strategyName: "my-strategy", note: "Simple moving average...", ... }]
+ * ```
+ */
+declare function listStrategies(): Promise<IStrategySchema[]>;
+/**
+ * Returns a list of all registered frame schemas.
+ *
+ * Retrieves all frames that have been registered via addFrame().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of frame schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listFrames, addFrame } from "backtest-kit";
+ *
+ * addFrame({
+ *   frameName: "1d-backtest",
+ *   note: "One day backtest period for testing",
+ *   interval: "1m",
+ *   startDate: new Date("2024-01-01T00:00:00Z"),
+ *   endDate: new Date("2024-01-02T00:00:00Z"),
+ * });
+ *
+ * const frames = listFrames();
+ * console.log(frames);
+ * // [{ frameName: "1d-backtest", note: "One day backtest...", ... }]
+ * ```
+ */
+declare function listFrames(): Promise<IFrameSchema[]>;
+
 /**
  * Contract for background execution completion events.
  *
@@ -696,6 +786,37 @@ interface DoneContract {
     symbol: string;
 }
 
+/**
+ * Contract for backtest progress events.
+ *
+ * Emitted during Backtest.background() execution to track progress.
+ * Contains information about total frames, processed frames, and completion percentage.
+ *
+ * @example
+ * ```typescript
+ * import { listenProgress } from "backtest-kit";
+ *
+ * listenProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`Processed: ${event.processedFrames} / ${event.totalFrames}`);
+ * });
+ * ```
+ */
+interface ProgressContract {
+    /** exchangeName - Name of the exchange used in execution */
+    exchangeName: string;
+    /** strategyName - Name of the strategy being executed */
+    strategyName: string;
+    /** symbol - Trading symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** totalFrames - Total number of frames to process */
+    totalFrames: number;
+    /** processedFrames - Number of frames processed so far */
+    processedFrames: number;
+    /** progress - Completion percentage from 0.0 to 1.0 */
+    progress: number;
+}
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -924,6 +1045,37 @@ declare function listenDone(fn: (event: DoneContract) => void): () => void;
  * ```
  */
 declare function listenDoneOnce(filterFn: (event: DoneContract) => boolean, fn: (event: DoneContract) => void): () => void;
+/**
+ * Subscribes to backtest progress events with queued async processing.
+ *
+ * Emits during Backtest.background() execution to track progress.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle progress events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenProgress, Backtest } from "backtest-kit";
+ *
+ * const unsubscribe = listenProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`${event.processedFrames} / ${event.totalFrames} frames`);
+ *   console.log(`Strategy: ${event.strategyName}, Symbol: ${event.symbol}`);
+ * });
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenProgress(fn: (event: ProgressContract) => void): () => void;
 
 /**
  * Fetches historical candle data from the registered exchange.
@@ -1026,540 +1178,976 @@ declare function getDate(): Promise<Date>;
  */
 declare function getMode(): Promise<"backtest" | "live">;
 
-declare const BASE_WAIT_FOR_INIT_SYMBOL: unique symbol;
 /**
- * Signal data stored in persistence layer.
- * Contains nullable signal for atomic updates.
- */
-interface ISignalData {
-    /** Current signal state (null when no active signal) */
-    signalRow: ISignalRow | null;
-}
-/**
- * Type helper for PersistBase instance.
- */
-type TPersistBase = InstanceType<typeof PersistBase>;
-/**
- * Constructor type for PersistBase.
- * Used for custom persistence adapters.
- */
-type TPersistBaseCtor<EntityName extends string = string, Entity extends IEntity = IEntity> = new (entityName: EntityName, baseDir: string) => IPersistBase<Entity>;
-/**
- * Entity identifier - string or number.
- */
-type EntityId = string | number;
-/**
- * Base interface for persisted entities.
+ * Statistical data calculated from backtest results.
+ *
+ * All numeric values are null if calculation is unsafe (NaN, Infinity, etc).
+ * Provides comprehensive metrics for strategy performance analysis.
+ *
+ * @example
+ * ```typescript
+ * const stats = await Backtest.getData("my-strategy");
+ *
+ * console.log(`Total signals: ${stats.totalSignals}`);
+ * console.log(`Win rate: ${stats.winRate}%`);
+ * console.log(`Sharpe Ratio: ${stats.sharpeRatio}`);
+ *
+ * // Access raw signal data
+ * stats.signalList.forEach(signal => {
+ *   console.log(`Signal ${signal.signal.id}: ${signal.pnl.pnlPercentage}%`);
+ * });
+ * ```
  */
-interface IEntity {
+interface BacktestStatistics {
+    /** Array of all closed signals with full details (price, PNL, timestamps, etc.) */
+    signalList: IStrategyTickResultClosed[];
+    /** Total number of closed signals */
+    totalSignals: number;
+    /** Number of winning signals (PNL > 0) */
+    winCount: number;
+    /** Number of losing signals (PNL < 0) */
+    lossCount: number;
+    /** Win rate as percentage (0-100), null if unsafe. Higher is better. */
+    winRate: number | null;
+    /** Average PNL per signal as percentage, null if unsafe. Higher is better. */
+    avgPnl: number | null;
+    /** Cumulative PNL across all signals as percentage, null if unsafe. Higher is better. */
+    totalPnl: number | null;
+    /** Standard deviation of returns (volatility metric), null if unsafe. Lower is better. */
+    stdDev: number | null;
+    /** Sharpe Ratio (risk-adjusted return = avgPnl / stdDev), null if unsafe. Higher is better. */
+    sharpeRatio: number | null;
+    /** Annualized Sharpe Ratio (sharpeRatio × √365), null if unsafe. Higher is better. */
+    annualizedSharpeRatio: number | null;
+    /** Certainty Ratio (avgWin / |avgLoss|), null if unsafe. Higher is better. */
+    certaintyRatio: number | null;
+    /** Expected yearly returns based on average trade duration and PNL, null if unsafe. Higher is better. */
+    expectedYearlyReturns: number | null;
 }
 /**
- * Persistence interface for CRUD operations.
- * Implemented by PersistBase.
+ * Service for generating and saving backtest markdown reports.
+ *
+ * Features:
+ * - Listens to signal events via onTick callback
+ * - Accumulates closed signals per strategy using memoized storage
+ * - Generates markdown tables with detailed signal information
+ * - Saves reports to disk in logs/backtest/{strategyName}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new BacktestMarkdownService();
+ *
+ * // Add to strategy callbacks
+ * addStrategy({
+ *   strategyName: "my-strategy",
+ *   callbacks: {
+ *     onTick: (symbol, result, backtest) => {
+ *       service.tick(result);
+ *     }
+ *   }
+ * });
+ *
+ * // After backtest, generate and save report
+ * await service.saveReport("my-strategy");
+ * ```
  */
-interface IPersistBase<Entity extends IEntity = IEntity> {
+declare class BacktestMarkdownService {
+    /** Logger service for debug output */
+    private readonly loggerService;
     /**
-     * Initialize persistence directory and validate existing files.
-     * Uses singleshot to ensure one-time execution.
+     * Memoized function to get or create ReportStorage for a strategy.
+     * Each strategy gets its own isolated storage instance.
+     */
+    private getStorage;
+    /**
+     * Processes tick events and accumulates closed signals.
+     * Should be called from IStrategyCallbacks.onTick.
      *
-     * @param initial - Whether this is the first initialization
-     * @returns Promise that resolves when initialization is complete
+     * Only processes closed signals - opened signals are ignored.
+     *
+     * @param data - Tick result from strategy execution (opened or closed)
+     *
+     * @example
+     * ```typescript
+     * const service = new BacktestMarkdownService();
+     *
+     * callbacks: {
+     *   onTick: (symbol, result, backtest) => {
+     *     service.tick(result);
+     *   }
+     * }
+     * ```
      */
-    waitForInit(initial: boolean): Promise<void>;
+    private tick;
     /**
-     * Read entity from persistence storage.
+     * Gets statistical data from all closed signals for a strategy.
+     * Delegates to ReportStorage.getData().
      *
-     * @param entityId - Unique entity identifier
-     * @returns Promise resolving to entity data
-     * @throws Error if entity not found or read fails
+     * @param strategyName - Strategy name to get data for
+     * @returns Statistical data object with all metrics
+     *
+     * @example
+     * ```typescript
+     * const service = new BacktestMarkdownService();
+     * const stats = await service.getData("my-strategy");
+     * console.log(stats.sharpeRatio, stats.winRate);
+     * ```
      */
-    readValue(entityId: EntityId): Promise<Entity>;
+    getData: (strategyName: StrategyName) => Promise<BacktestStatistics>;
     /**
-     * Check if entity exists in storage.
+     * Generates markdown report with all closed signals for a strategy.
+     * Delegates to ReportStorage.generateReport().
      *
-     * @param entityId - Unique entity identifier
-     * @returns Promise resolving to true if exists, false otherwise
+     * @param strategyName - Strategy name to generate report for
+     * @returns Markdown formatted report string with table of all closed signals
+     *
+     * @example
+     * ```typescript
+     * const service = new BacktestMarkdownService();
+     * const markdown = await service.getReport("my-strategy");
+     * console.log(markdown);
+     * ```
      */
-    hasValue(entityId: EntityId): Promise<boolean>;
+    getReport: (strategyName: StrategyName) => Promise<string>;
     /**
-     * Write entity to storage with atomic file writes.
+     * Saves strategy report to disk.
+     * Creates directory if it doesn't exist.
+     * Delegates to ReportStorage.dump().
      *
-     * @param entityId - Unique entity identifier
-     * @param entity - Entity data to persist
-     * @returns Promise that resolves when write is complete
-     * @throws Error if write fails
+     * @param strategyName - Strategy name to save report for
+     * @param path - Directory path to save report (default: "./logs/backtest")
+     *
+     * @example
+     * ```typescript
+     * const service = new BacktestMarkdownService();
+     *
+     * // Save to default path: ./logs/backtest/my-strategy.md
+     * await service.dump("my-strategy");
+     *
+     * // Save to custom path: ./custom/path/my-strategy.md
+     * await service.dump("my-strategy", "./custom/path");
+     * ```
      */
-    writeValue(entityId: EntityId, entity: Entity): Promise<void>;
-}
-/**
- * Base class for file-based persistence with atomic writes.
- *
- * Features:
- * - Atomic file writes using writeFileAtomic
- * - Auto-validation and cleanup of corrupted files
- * - Async generator support for iteration
- * - Retry logic for file deletion
- *
- * @example
- * ```typescript
- * const persist = new PersistBase("my-entity", "./data");
- * await persist.waitForInit(true);
- * await persist.writeValue("key1", { data: "value" });
- * const value = await persist.readValue("key1");
- * ```
- */
-declare const PersistBase: {
-    new <EntityName extends string = string>(entityName: EntityName, baseDir?: string): {
-        /** Computed directory path for entity storage */
-        _directory: string;
-        readonly entityName: EntityName;
-        readonly baseDir: string;
-        /**
-         * Computes file path for entity ID.
-         *
-         * @param entityId - Entity identifier
-         * @returns Full file path to entity JSON file
-         */
-        _getFilePath(entityId: EntityId): string;
-        waitForInit(initial: boolean): Promise<void>;
-        /**
-         * Returns count of persisted entities.
-         *
-         * @returns Promise resolving to number of .json files in directory
-         */
-        getCount(): Promise<number>;
-        readValue<T extends IEntity = IEntity>(entityId: EntityId): Promise<T>;
-        hasValue(entityId: EntityId): Promise<boolean>;
-        writeValue<T extends IEntity = IEntity>(entityId: EntityId, entity: T): Promise<void>;
-        /**
-         * Removes entity from storage.
-         *
-         * @param entityId - Entity identifier to remove
-         * @returns Promise that resolves when entity is deleted
-         * @throws Error if entity not found or deletion fails
-         */
-        removeValue(entityId: EntityId): Promise<void>;
-        /**
-         * Removes all entities from storage.
-         *
-         * @returns Promise that resolves when all entities are deleted
-         * @throws Error if deletion fails
-         */
-        removeAll(): Promise<void>;
-        /**
-         * Async generator yielding all entity values.
-         * Sorted alphanumerically by entity ID.
-         *
-         * @returns AsyncGenerator yielding entities
-         * @throws Error if reading fails
-         */
-        values<T extends IEntity = IEntity>(): AsyncGenerator<T>;
-        /**
-         * Async generator yielding all entity IDs.
-         * Sorted alphanumerically.
-         *
-         * @returns AsyncGenerator yielding entity IDs
-         * @throws Error if reading fails
-         */
-        keys(): AsyncGenerator<EntityId>;
-        /**
-         * Filters entities by predicate function.
-         *
-         * @param predicate - Filter function
-         * @returns AsyncGenerator yielding filtered entities
-         */
-        filter<T extends IEntity = IEntity>(predicate: (value: T) => boolean): AsyncGenerator<T>;
-        /**
-         * Takes first N entities, optionally filtered.
-         *
-         * @param total - Maximum number of entities to yield
-         * @param predicate - Optional filter function
-         * @returns AsyncGenerator yielding up to total entities
-         */
-        take<T extends IEntity = IEntity>(total: number, predicate?: (value: T) => boolean): AsyncGenerator<T>;
-        [BASE_WAIT_FOR_INIT_SYMBOL]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-        /**
-         * Async iterator implementation.
-         * Delegates to values() generator.
-         *
-         * @returns AsyncIterableIterator yielding entities
-         */
-        [Symbol.asyncIterator](): AsyncIterableIterator<any>;
-    };
-};
-/**
- * Utility class for managing signal persistence.
- *
- * Features:
- * - Memoized storage instances per strategy
- * - Custom adapter support
- * - Atomic read/write operations
- * - Crash-safe signal state management
- *
- * Used by ClientStrategy for live mode persistence.
- */
-declare class PersistSignalUtils {
-    private PersistSignalFactory;
-    private getSignalStorage;
+    dump: (strategyName: StrategyName, path?: string) => Promise<void>;
     /**
-     * Registers a custom persistence adapter.
+     * Clears accumulated signal data from storage.
+     * If strategyName is provided, clears only that strategy's data.
+     * If strategyName is omitted, clears all strategies' data.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param strategyName - Optional strategy name to clear specific strategy data
      *
      * @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)); }
-     * }
-     * PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
-     * ```
-     */
-    usePersistSignalAdapter(Ctor: TPersistBaseCtor<StrategyName, ISignalData>): void;
-    /**
-     * Reads persisted signal data for a strategy and symbol.
+     * const service = new BacktestMarkdownService();
      *
-     * Called by ClientStrategy.waitForInit() to restore state.
-     * Returns null if no signal exists.
+     * // Clear specific strategy data
+     * await service.clear("my-strategy");
      *
-     * @param strategyName - Strategy identifier
-     * @param symbol - Trading pair symbol
-     * @returns Promise resolving to signal or null
+     * // Clear all strategies' data
+     * await service.clear();
+     * ```
      */
-    readSignalData: (strategyName: StrategyName, symbol: string) => Promise<ISignalRow | null>;
+    clear: (strategyName?: StrategyName) => Promise<void>;
     /**
-     * Writes signal data to disk with atomic file writes.
-     *
-     * Called by ClientStrategy.setPendingSignal() to persist state.
-     * Uses atomic writes to prevent corruption on crashes.
+     * Initializes the service by subscribing to backtest signal events.
+     * Uses singleshot to ensure initialization happens only once.
+     * Automatically called on first use.
      *
-     * @param signalRow - Signal data (null to clear)
-     * @param strategyName - Strategy identifier
-     * @param symbol - Trading pair symbol
-     * @returns Promise that resolves when write is complete
+     * @example
+     * ```typescript
+     * const service = new BacktestMarkdownService();
+     * await service.init(); // Subscribe to backtest events
+     * ```
      */
-    writeSignalData: (signalRow: ISignalRow | null, strategyName: StrategyName, symbol: string) => Promise<void>;
+    protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
 }
+
 /**
- * Global singleton instance of PersistSignalUtils.
- * Used by ClientStrategy for signal persistence.
+ * Unified tick event data for report generation.
+ * Contains all information about a tick event regardless of action type.
+ */
+interface TickEvent {
+    /** Event timestamp in milliseconds */
+    timestamp: number;
+    /** Event action type */
+    action: "idle" | "opened" | "active" | "closed";
+    /** Trading pair symbol (only for non-idle events) */
+    symbol?: string;
+    /** Signal ID (only for opened/active/closed) */
+    signalId?: string;
+    /** Position type (only for opened/active/closed) */
+    position?: string;
+    /** Signal note (only for opened/active/closed) */
+    note?: string;
+    /** Current price */
+    currentPrice: number;
+    /** Open price (only for opened/active/closed) */
+    openPrice?: number;
+    /** Take profit price (only for opened/active/closed) */
+    takeProfit?: number;
+    /** Stop loss price (only for opened/active/closed) */
+    stopLoss?: number;
+    /** PNL percentage (only for closed) */
+    pnl?: number;
+    /** Close reason (only for closed) */
+    closeReason?: string;
+    /** Duration in minutes (only for closed) */
+    duration?: number;
+}
+/**
+ * Statistical data calculated from live trading results.
+ *
+ * All numeric values are null if calculation is unsafe (NaN, Infinity, etc).
+ * Provides comprehensive metrics for live trading performance analysis.
  *
  * @example
  * ```typescript
- * // Custom adapter
- * PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
+ * const stats = await Live.getData("my-strategy");
  *
- * // Read signal
- * const signal = await PersistSignalAdaper.readSignalData("my-strategy", "BTCUSDT");
+ * console.log(`Total events: ${stats.totalEvents}`);
+ * console.log(`Closed signals: ${stats.totalClosed}`);
+ * console.log(`Win rate: ${stats.winRate}%`);
+ * console.log(`Sharpe Ratio: ${stats.sharpeRatio}`);
  *
- * // Write signal
- * await PersistSignalAdaper.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * // Access raw event data (includes idle, opened, active, closed)
+ * stats.eventList.forEach(event => {
+ *   if (event.action === "closed") {
+ *     console.log(`Closed signal: ${event.pnl}%`);
+ *   }
+ * });
  * ```
  */
-declare const PersistSignalAdaper: PersistSignalUtils;
-
+interface LiveStatistics {
+    /** Array of all events (idle, opened, active, closed) with full details */
+    eventList: TickEvent[];
+    /** Total number of all events (includes idle, opened, active, closed) */
+    totalEvents: number;
+    /** Total number of closed signals only */
+    totalClosed: number;
+    /** Number of winning closed signals (PNL > 0) */
+    winCount: number;
+    /** Number of losing closed signals (PNL < 0) */
+    lossCount: number;
+    /** Win rate as percentage (0-100) based on closed signals, null if unsafe. Higher is better. */
+    winRate: number | null;
+    /** Average PNL per closed signal as percentage, null if unsafe. Higher is better. */
+    avgPnl: number | null;
+    /** Cumulative PNL across all closed signals as percentage, null if unsafe. Higher is better. */
+    totalPnl: number | null;
+    /** Standard deviation of returns (volatility metric), null if unsafe. Lower is better. */
+    stdDev: number | null;
+    /** Sharpe Ratio (risk-adjusted return = avgPnl / stdDev), null if unsafe. Higher is better. */
+    sharpeRatio: number | null;
+    /** Annualized Sharpe Ratio (sharpeRatio × √365), null if unsafe. Higher is better. */
+    annualizedSharpeRatio: number | null;
+    /** Certainty Ratio (avgWin / |avgLoss|), null if unsafe. Higher is better. */
+    certaintyRatio: number | null;
+    /** Expected yearly returns based on average trade duration and PNL, null if unsafe. Higher is better. */
+    expectedYearlyReturns: number | null;
+}
 /**
- * Utility class for backtest operations.
+ * Service for generating and saving live trading markdown reports.
  *
- * Provides simplified access to backtestGlobalService.run() with logging.
- * Exported as singleton instance for convenient usage.
+ * Features:
+ * - Listens to all signal events via onTick callback
+ * - Accumulates all events (idle, opened, active, closed) per strategy
+ * - Generates markdown tables with detailed event information
+ * - Provides trading statistics (win rate, average PNL)
+ * - Saves reports to disk in logs/live/{strategyName}.md
  *
  * @example
  * ```typescript
- * import { Backtest } from "./classes/Backtest";
+ * const service = new LiveMarkdownService();
  *
- * for await (const result of Backtest.run("BTCUSDT", {
+ * // Add to strategy callbacks
+ * addStrategy({
  *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: "1d-backtest"
- * })) {
- *   console.log("Closed signal PNL:", result.pnl.pnlPercentage);
- * }
+ *   callbacks: {
+ *     onTick: (symbol, result, backtest) => {
+ *       if (!backtest) {
+ *         service.tick(result);
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * // Later: generate and save report
+ * await service.dump("my-strategy");
  * ```
  */
-declare class BacktestUtils {
+declare class LiveMarkdownService {
+    /** Logger service for debug output */
+    private readonly loggerService;
     /**
-     * Runs backtest for a symbol with context propagation.
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy, exchange, and frame names
-     * @returns Async generator yielding closed signals with PNL
+     * Memoized function to get or create ReportStorage for a strategy.
+     * Each strategy gets its own isolated storage instance.
      */
-    run: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-        frameName: string;
-    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+    private getStorage;
     /**
-     * Runs backtest in background without yielding results.
+     * Processes tick events and accumulates all event types.
+     * Should be called from IStrategyCallbacks.onTick.
      *
-     * Consumes all backtest results internally without exposing them.
-     * Useful for running backtests for side effects only (callbacks, logging).
+     * Processes all event types: idle, opened, active, closed.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy, exchange, and frame names
-     * @returns Cancellation closure
+     * @param data - Tick result from strategy execution
      *
      * @example
      * ```typescript
-     * // Run backtest silently, only callbacks will fire
-     * await Backtest.background("BTCUSDT", {
-     *   strategyName: "my-strategy",
-     *   exchangeName: "my-exchange",
-     *   frameName: "1d-backtest"
-     * });
-     * console.log("Backtest completed");
+     * const service = new LiveMarkdownService();
+     *
+     * callbacks: {
+     *   onTick: (symbol, result, backtest) => {
+     *     if (!backtest) {
+     *       service.tick(result);
+     *     }
+     *   }
+     * }
      * ```
      */
-    background: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-        frameName: string;
-    }) => () => void;
+    private tick;
     /**
-     * Generates markdown report with all closed signals for a strategy.
+     * Gets statistical data from all live trading events for a strategy.
+     * Delegates to ReportStorage.getData().
+     *
+     * @param strategyName - Strategy name to get data for
+     * @returns Statistical data object with all metrics
+     *
+     * @example
+     * ```typescript
+     * const service = new LiveMarkdownService();
+     * const stats = await service.getData("my-strategy");
+     * console.log(stats.sharpeRatio, stats.winRate);
+     * ```
+     */
+    getData: (strategyName: StrategyName) => Promise<LiveStatistics>;
+    /**
+     * Generates markdown report with all events for a strategy.
+     * Delegates to ReportStorage.getReport().
      *
      * @param strategyName - Strategy name to generate report for
-     * @returns Promise resolving to markdown formatted report string
+     * @returns Markdown formatted report string with table of all events
      *
      * @example
      * ```typescript
-     * const markdown = await Backtest.getReport("my-strategy");
+     * const service = new LiveMarkdownService();
+     * const markdown = await service.getReport("my-strategy");
      * console.log(markdown);
      * ```
      */
     getReport: (strategyName: StrategyName) => Promise<string>;
     /**
      * Saves strategy report to disk.
+     * Creates directory if it doesn't exist.
+     * Delegates to ReportStorage.dump().
      *
      * @param strategyName - Strategy name to save report for
-     * @param path - Optional directory path to save report (default: "./logs/backtest")
+     * @param path - Directory path to save report (default: "./logs/live")
      *
      * @example
      * ```typescript
-     * // Save to default path: ./logs/backtest/my-strategy.md
-     * await Backtest.dump("my-strategy");
+     * const service = new LiveMarkdownService();
+     *
+     * // Save to default path: ./logs/live/my-strategy.md
+     * await service.dump("my-strategy");
      *
      * // Save to custom path: ./custom/path/my-strategy.md
-     * await Backtest.dump("my-strategy", "./custom/path");
+     * await service.dump("my-strategy", "./custom/path");
      * ```
      */
     dump: (strategyName: StrategyName, path?: string) => Promise<void>;
-}
-/**
- * Singleton instance of BacktestUtils for convenient backtest operations.
- *
- * @example
- * ```typescript
- * import { Backtest } from "./classes/Backtest";
- *
- * for await (const result of Backtest.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: "1d-backtest"
- * })) {
- *   if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.pnlPercentage);
- *   }
- * }
- * ```
- */
-declare const Backtest: BacktestUtils;
-
-/**
- * Utility class for live trading operations.
- *
- * Provides simplified access to liveGlobalService.run() with logging.
- * Exported as singleton instance for convenient usage.
- *
- * Features:
- * - Infinite async generator (never completes)
- * - Crash recovery via persisted state
- * - Real-time progression with Date.now()
- *
- * @example
- * ```typescript
- * import { Live } from "./classes/Live";
- *
- * // Infinite loop - use Ctrl+C to stop
- * for await (const result of Live.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: ""
- * })) {
- *   if (result.action === "opened") {
- *     console.log("Signal opened:", result.signal);
- *   } else if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.pnlPercentage);
- *   }
- * }
- * ```
- */
-declare class LiveUtils {
-    /**
-     * Runs live trading for a symbol with context propagation.
-     *
-     * Infinite async generator with crash recovery support.
-     * Process can crash and restart - state will be recovered from disk.
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy and exchange names
-     * @returns Infinite async generator yielding opened and closed signals
-     */
-    run: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
     /**
-     * Runs live trading in background without yielding results.
-     *
-     * Consumes all live trading results internally without exposing them.
-     * Infinite loop - will run until process is stopped or crashes.
-     * Useful for running live trading for side effects only (callbacks, persistence).
+     * Clears accumulated event data from storage.
+     * If strategyName is provided, clears only that strategy's data.
+     * If strategyName is omitted, clears all strategies' data.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy and exchange names
-     * @returns Cancellation closure
+     * @param strategyName - Optional strategy name to clear specific strategy data
      *
      * @example
      * ```typescript
-     * // Run live trading silently in background, only callbacks will fire
-     * // This will run forever until Ctrl+C
-     * await Live.background("BTCUSDT", {
-     *   strategyName: "my-strategy",
-     *   exchangeName: "my-exchange"
-     * });
-     * ```
-     */
-    background: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-    }) => () => void;
-    /**
-     * Generates markdown report with all events for a strategy.
+     * const service = new LiveMarkdownService();
      *
-     * @param strategyName - Strategy name to generate report for
-     * @returns Promise resolving to markdown formatted report string
+     * // Clear specific strategy data
+     * await service.clear("my-strategy");
      *
-     * @example
-     * ```typescript
-     * const markdown = await Live.getReport("my-strategy");
-     * console.log(markdown);
+     * // Clear all strategies' data
+     * await service.clear();
      * ```
      */
-    getReport: (strategyName: StrategyName) => Promise<string>;
+    clear: (strategyName?: StrategyName) => Promise<void>;
     /**
-     * Saves strategy report to disk.
-     *
-     * @param strategyName - Strategy name to save report for
-     * @param path - Optional directory path to save report (default: "./logs/live")
+     * Initializes the service by subscribing to live signal events.
+     * Uses singleshot to ensure initialization happens only once.
+     * Automatically called on first use.
      *
      * @example
      * ```typescript
-     * // Save to default path: ./logs/live/my-strategy.md
-     * await Live.dump("my-strategy");
-     *
-     * // Save to custom path: ./custom/path/my-strategy.md
-     * await Live.dump("my-strategy", "./custom/path");
+     * const service = new LiveMarkdownService();
+     * await service.init(); // Subscribe to live events
      * ```
      */
-    dump: (strategyName: StrategyName, path?: string) => Promise<void>;
+    protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
 }
+
+declare const BASE_WAIT_FOR_INIT_SYMBOL: unique symbol;
 /**
- * Singleton instance of LiveUtils for convenient live trading operations.
- *
- * @example
- * ```typescript
- * import { Live } from "./classes/Live";
- *
- * for await (const result of Live.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- * })) {
- *   console.log("Result:", result.action);
- * }
- * ```
+ * Signal data stored in persistence layer.
+ * Contains nullable signal for atomic updates.
  */
-declare const Live: LiveUtils;
-
+interface ISignalData {
+    /** Current signal state (null when no active signal) */
+    signalRow: ISignalRow | null;
+}
 /**
- * Logger service with automatic context injection.
- *
- * Features:
- * - Delegates to user-provided logger via setLogger()
- * - Automatically appends method context (strategyName, exchangeName, frameName)
- * - Automatically appends execution context (symbol, when, backtest)
- * - Defaults to NOOP_LOGGER if no logger configured
- *
- * Used throughout the framework for consistent logging with context.
+ * Type helper for PersistBase instance.
  */
-declare class LoggerService implements ILogger {
-    private readonly methodContextService;
-    private readonly executionContextService;
-    private _commonLogger;
-    /**
-     * Gets current method context if available.
-     * Contains strategyName, exchangeName, frameName from MethodContextService.
-     */
-    private get methodContext();
-    /**
-     * Gets current execution context if available.
-     * Contains symbol, when, backtest from ExecutionContextService.
-     */
-    private get executionContext();
-    /**
-     * Logs general-purpose message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    log: (topic: string, ...args: any[]) => Promise<void>;
+type TPersistBase = InstanceType<typeof PersistBase>;
+/**
+ * Constructor type for PersistBase.
+ * Used for custom persistence adapters.
+ */
+type TPersistBaseCtor<EntityName extends string = string, Entity extends IEntity = IEntity> = new (entityName: EntityName, baseDir: string) => IPersistBase<Entity>;
+/**
+ * Entity identifier - string or number.
+ */
+type EntityId = string | number;
+/**
+ * Base interface for persisted entities.
+ */
+interface IEntity {
+}
+/**
+ * Persistence interface for CRUD operations.
+ * Implemented by PersistBase.
+ */
+interface IPersistBase<Entity extends IEntity = IEntity> {
     /**
-     * Logs debug-level message with automatic context injection.
+     * Initialize persistence directory and validate existing files.
+     * Uses singleshot to ensure one-time execution.
      *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
      */
-    debug: (topic: string, ...args: any[]) => Promise<void>;
+    waitForInit(initial: boolean): Promise<void>;
     /**
-     * Logs info-level message with automatic context injection.
+     * Read entity from persistence storage.
      *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
+     * @param entityId - Unique entity identifier
+     * @returns Promise resolving to entity data
+     * @throws Error if entity not found or read fails
      */
-    info: (topic: string, ...args: any[]) => Promise<void>;
+    readValue(entityId: EntityId): Promise<Entity>;
     /**
-     * Logs warning-level message with automatic context injection.
+     * Check if entity exists in storage.
      *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
+     * @param entityId - Unique entity identifier
+     * @returns Promise resolving to true if exists, false otherwise
      */
-    warn: (topic: string, ...args: any[]) => Promise<void>;
+    hasValue(entityId: EntityId): Promise<boolean>;
     /**
-     * Sets custom logger implementation.
+     * Write entity to storage with atomic file writes.
      *
-     * @param logger - Custom logger implementing ILogger interface
+     * @param entityId - Unique entity identifier
+     * @param entity - Entity data to persist
+     * @returns Promise that resolves when write is complete
+     * @throws Error if write fails
      */
-    setLogger: (logger: ILogger) => void;
+    writeValue(entityId: EntityId, entity: Entity): Promise<void>;
 }
-
 /**
- * Client implementation for exchange data access.
+ * Base class for file-based persistence with atomic writes.
  *
  * Features:
- * - Historical candle fetching (backwards from execution context)
- * - Future candle fetching (forwards for backtest)
- * - VWAP calculation from last 5 1m candles
- * - Price/quantity formatting for exchange
- *
- * All methods use prototype functions for memory efficiency.
+ * - Atomic file writes using writeFileAtomic
+ * - Auto-validation and cleanup of corrupted files
+ * - Async generator support for iteration
+ * - Retry logic for file deletion
  *
  * @example
  * ```typescript
- * const exchange = new ClientExchange({
- *   exchangeName: "binance",
- *   getCandles: async (symbol, interval, since, limit) => [...],
- *   formatPrice: async (symbol, price) => price.toFixed(2),
+ * const persist = new PersistBase("my-entity", "./data");
+ * await persist.waitForInit(true);
+ * await persist.writeValue("key1", { data: "value" });
+ * const value = await persist.readValue("key1");
+ * ```
+ */
+declare const PersistBase: {
+    new <EntityName extends string = string>(entityName: EntityName, baseDir?: string): {
+        /** Computed directory path for entity storage */
+        _directory: string;
+        readonly entityName: EntityName;
+        readonly baseDir: string;
+        /**
+         * Computes file path for entity ID.
+         *
+         * @param entityId - Entity identifier
+         * @returns Full file path to entity JSON file
+         */
+        _getFilePath(entityId: EntityId): string;
+        waitForInit(initial: boolean): Promise<void>;
+        /**
+         * Returns count of persisted entities.
+         *
+         * @returns Promise resolving to number of .json files in directory
+         */
+        getCount(): Promise<number>;
+        readValue<T extends IEntity = IEntity>(entityId: EntityId): Promise<T>;
+        hasValue(entityId: EntityId): Promise<boolean>;
+        writeValue<T extends IEntity = IEntity>(entityId: EntityId, entity: T): Promise<void>;
+        /**
+         * Removes entity from storage.
+         *
+         * @param entityId - Entity identifier to remove
+         * @returns Promise that resolves when entity is deleted
+         * @throws Error if entity not found or deletion fails
+         */
+        removeValue(entityId: EntityId): Promise<void>;
+        /**
+         * Removes all entities from storage.
+         *
+         * @returns Promise that resolves when all entities are deleted
+         * @throws Error if deletion fails
+         */
+        removeAll(): Promise<void>;
+        /**
+         * Async generator yielding all entity values.
+         * Sorted alphanumerically by entity ID.
+         *
+         * @returns AsyncGenerator yielding entities
+         * @throws Error if reading fails
+         */
+        values<T extends IEntity = IEntity>(): AsyncGenerator<T>;
+        /**
+         * Async generator yielding all entity IDs.
+         * Sorted alphanumerically.
+         *
+         * @returns AsyncGenerator yielding entity IDs
+         * @throws Error if reading fails
+         */
+        keys(): AsyncGenerator<EntityId>;
+        /**
+         * Filters entities by predicate function.
+         *
+         * @param predicate - Filter function
+         * @returns AsyncGenerator yielding filtered entities
+         */
+        filter<T extends IEntity = IEntity>(predicate: (value: T) => boolean): AsyncGenerator<T>;
+        /**
+         * Takes first N entities, optionally filtered.
+         *
+         * @param total - Maximum number of entities to yield
+         * @param predicate - Optional filter function
+         * @returns AsyncGenerator yielding up to total entities
+         */
+        take<T extends IEntity = IEntity>(total: number, predicate?: (value: T) => boolean): AsyncGenerator<T>;
+        [BASE_WAIT_FOR_INIT_SYMBOL]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+        /**
+         * Async iterator implementation.
+         * Delegates to values() generator.
+         *
+         * @returns AsyncIterableIterator yielding entities
+         */
+        [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+    };
+};
+/**
+ * Utility class for managing signal persistence.
+ *
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations
+ * - Crash-safe signal state management
+ *
+ * Used by ClientStrategy for live mode persistence.
+ */
+declare class PersistSignalUtils {
+    private PersistSignalFactory;
+    private getSignalStorage;
+    /**
+     * 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)); }
+     * }
+     * PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
+     * ```
+     */
+    usePersistSignalAdapter(Ctor: TPersistBaseCtor<StrategyName, ISignalData>): void;
+    /**
+     * Reads persisted signal data for a strategy and symbol.
+     *
+     * Called by ClientStrategy.waitForInit() to restore state.
+     * Returns null if no signal exists.
+     *
+     * @param strategyName - Strategy identifier
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to signal or null
+     */
+    readSignalData: (strategyName: StrategyName, symbol: string) => Promise<ISignalRow | null>;
+    /**
+     * Writes signal data to disk with atomic file writes.
+     *
+     * Called by ClientStrategy.setPendingSignal() to persist state.
+     * Uses atomic writes to prevent corruption on crashes.
+     *
+     * @param signalRow - Signal data (null to clear)
+     * @param strategyName - Strategy identifier
+     * @param symbol - Trading pair symbol
+     * @returns Promise that resolves when write is complete
+     */
+    writeSignalData: (signalRow: ISignalRow | null, strategyName: StrategyName, symbol: string) => Promise<void>;
+}
+/**
+ * Global singleton instance of PersistSignalUtils.
+ * Used by ClientStrategy for signal persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
+ *
+ * // Read signal
+ * const signal = await PersistSignalAdaper.readSignalData("my-strategy", "BTCUSDT");
+ *
+ * // Write signal
+ * await PersistSignalAdaper.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * ```
+ */
+declare const PersistSignalAdaper: PersistSignalUtils;
+
+/**
+ * Utility class for backtest operations.
+ *
+ * Provides simplified access to backtestGlobalService.run() with logging.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Backtest } from "./classes/Backtest";
+ *
+ * for await (const result of Backtest.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest"
+ * })) {
+ *   console.log("Closed signal PNL:", result.pnl.pnlPercentage);
+ * }
+ * ```
+ */
+declare class BacktestUtils {
+    /**
+     * Runs backtest for a symbol with context propagation.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Async generator yielding closed signals with PNL
+     */
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+    /**
+     * Runs backtest in background without yielding results.
+     *
+     * Consumes all backtest results internally without exposing them.
+     * Useful for running backtests for side effects only (callbacks, logging).
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Cancellation closure
+     *
+     * @example
+     * ```typescript
+     * // Run backtest silently, only callbacks will fire
+     * await Backtest.background("BTCUSDT", {
+     *   strategyName: "my-strategy",
+     *   exchangeName: "my-exchange",
+     *   frameName: "1d-backtest"
+     * });
+     * console.log("Backtest completed");
+     * ```
+     */
+    background: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => () => void;
+    /**
+     * Gets statistical data from all closed signals for a strategy.
+     *
+     * @param strategyName - Strategy name to get data for
+     * @returns Promise resolving to statistical data object
+     *
+     * @example
+     * ```typescript
+     * const stats = await Backtest.getData("my-strategy");
+     * console.log(stats.sharpeRatio, stats.winRate);
+     * ```
+     */
+    getData: (strategyName: StrategyName) => Promise<BacktestStatistics>;
+    /**
+     * Generates markdown report with all closed signals for a strategy.
+     *
+     * @param strategyName - Strategy name to generate report for
+     * @returns Promise resolving to markdown formatted report string
+     *
+     * @example
+     * ```typescript
+     * const markdown = await Backtest.getReport("my-strategy");
+     * console.log(markdown);
+     * ```
+     */
+    getReport: (strategyName: StrategyName) => Promise<string>;
+    /**
+     * Saves strategy report to disk.
+     *
+     * @param strategyName - Strategy name to save report for
+     * @param path - Optional directory path to save report (default: "./logs/backtest")
+     *
+     * @example
+     * ```typescript
+     * // Save to default path: ./logs/backtest/my-strategy.md
+     * await Backtest.dump("my-strategy");
+     *
+     * // Save to custom path: ./custom/path/my-strategy.md
+     * await Backtest.dump("my-strategy", "./custom/path");
+     * ```
+     */
+    dump: (strategyName: StrategyName, path?: string) => Promise<void>;
+}
+/**
+ * Singleton instance of BacktestUtils for convenient backtest operations.
+ *
+ * @example
+ * ```typescript
+ * import { Backtest } from "./classes/Backtest";
+ *
+ * for await (const result of Backtest.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest"
+ * })) {
+ *   if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+declare const Backtest: BacktestUtils;
+
+/**
+ * Utility class for live trading operations.
+ *
+ * Provides simplified access to liveGlobalService.run() with logging.
+ * Exported as singleton instance for convenient usage.
+ *
+ * Features:
+ * - Infinite async generator (never completes)
+ * - Crash recovery via persisted state
+ * - Real-time progression with Date.now()
+ *
+ * @example
+ * ```typescript
+ * import { Live } from "./classes/Live";
+ *
+ * // Infinite loop - use Ctrl+C to stop
+ * for await (const result of Live.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: ""
+ * })) {
+ *   if (result.action === "opened") {
+ *     console.log("Signal opened:", result.signal);
+ *   } else if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+declare class LiveUtils {
+    /**
+     * Runs live trading for a symbol with context propagation.
+     *
+     * Infinite async generator with crash recovery support.
+     * Process can crash and restart - state will be recovered from disk.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy and exchange names
+     * @returns Infinite async generator yielding opened and closed signals
+     */
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+    /**
+     * Runs live trading in background without yielding results.
+     *
+     * Consumes all live trading results internally without exposing them.
+     * Infinite loop - will run until process is stopped or crashes.
+     * Useful for running live trading for side effects only (callbacks, persistence).
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy and exchange names
+     * @returns Cancellation closure
+     *
+     * @example
+     * ```typescript
+     * // Run live trading silently in background, only callbacks will fire
+     * // This will run forever until Ctrl+C
+     * await Live.background("BTCUSDT", {
+     *   strategyName: "my-strategy",
+     *   exchangeName: "my-exchange"
+     * });
+     * ```
+     */
+    background: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+    }) => () => void;
+    /**
+     * Gets statistical data from all live trading events for a strategy.
+     *
+     * @param strategyName - Strategy name to get data for
+     * @returns Promise resolving to statistical data object
+     *
+     * @example
+     * ```typescript
+     * const stats = await Live.getData("my-strategy");
+     * console.log(stats.sharpeRatio, stats.winRate);
+     * ```
+     */
+    getData: (strategyName: StrategyName) => Promise<LiveStatistics>;
+    /**
+     * Generates markdown report with all events for a strategy.
+     *
+     * @param strategyName - Strategy name to generate report for
+     * @returns Promise resolving to markdown formatted report string
+     *
+     * @example
+     * ```typescript
+     * const markdown = await Live.getReport("my-strategy");
+     * console.log(markdown);
+     * ```
+     */
+    getReport: (strategyName: StrategyName) => Promise<string>;
+    /**
+     * Saves strategy report to disk.
+     *
+     * @param strategyName - Strategy name to save report for
+     * @param path - Optional directory path to save report (default: "./logs/live")
+     *
+     * @example
+     * ```typescript
+     * // Save to default path: ./logs/live/my-strategy.md
+     * await Live.dump("my-strategy");
+     *
+     * // Save to custom path: ./custom/path/my-strategy.md
+     * await Live.dump("my-strategy", "./custom/path");
+     * ```
+     */
+    dump: (strategyName: StrategyName, path?: string) => Promise<void>;
+}
+/**
+ * Singleton instance of LiveUtils for convenient live trading operations.
+ *
+ * @example
+ * ```typescript
+ * import { Live } from "./classes/Live";
+ *
+ * for await (const result of Live.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ * })) {
+ *   console.log("Result:", result.action);
+ * }
+ * ```
+ */
+declare const Live: LiveUtils;
+
+/**
+ * Logger service with automatic context injection.
+ *
+ * Features:
+ * - Delegates to user-provided logger via setLogger()
+ * - Automatically appends method context (strategyName, exchangeName, frameName)
+ * - Automatically appends execution context (symbol, when, backtest)
+ * - Defaults to NOOP_LOGGER if no logger configured
+ *
+ * Used throughout the framework for consistent logging with context.
+ */
+declare class LoggerService implements ILogger {
+    private readonly methodContextService;
+    private readonly executionContextService;
+    private _commonLogger;
+    /**
+     * Gets current method context if available.
+     * Contains strategyName, exchangeName, frameName from MethodContextService.
+     */
+    private get methodContext();
+    /**
+     * Gets current execution context if available.
+     * Contains symbol, when, backtest from ExecutionContextService.
+     */
+    private get executionContext();
+    /**
+     * Logs general-purpose message with automatic context injection.
+     *
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
+     */
+    log: (topic: string, ...args: any[]) => Promise<void>;
+    /**
+     * Logs debug-level message with automatic context injection.
+     *
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
+     */
+    debug: (topic: string, ...args: any[]) => Promise<void>;
+    /**
+     * Logs info-level message with automatic context injection.
+     *
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
+     */
+    info: (topic: string, ...args: any[]) => Promise<void>;
+    /**
+     * Logs warning-level message with automatic context injection.
+     *
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
+     */
+    warn: (topic: string, ...args: any[]) => Promise<void>;
+    /**
+     * Sets custom logger implementation.
+     *
+     * @param logger - Custom logger implementing ILogger interface
+     */
+    setLogger: (logger: ILogger) => void;
+}
+
+/**
+ * Client implementation for exchange data access.
+ *
+ * Features:
+ * - Historical candle fetching (backwards from execution context)
+ * - Future candle fetching (forwards for backtest)
+ * - VWAP calculation from last 5 1m candles
+ * - Price/quantity formatting for exchange
+ *
+ * All methods use prototype functions for memory efficiency.
+ *
+ * @example
+ * ```typescript
+ * const exchange = new ClientExchange({
+ *   exchangeName: "binance",
+ *   getCandles: async (symbol, interval, since, limit) => [...],
+ *   formatPrice: async (symbol, price) => price.toFixed(2),
  *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
  *   execution: executionService,
  *   logger: loggerService,
@@ -1903,714 +2491,464 @@ declare class ExchangeGlobalService {
      * @param backtest - Whether running in backtest mode
      * @returns Promise resolving to formatted price string
      */
-    formatPrice: (symbol: string, price: number, when: Date, backtest: boolean) => Promise<string>;
-    /**
-     * Formats quantity with execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param quantity - Quantity to format
-     * @param when - Timestamp for context
-     * @param backtest - Whether running in backtest mode
-     * @returns Promise resolving to formatted quantity string
-     */
-    formatQuantity: (symbol: string, quantity: number, when: Date, backtest: boolean) => Promise<string>;
-}
-
-/**
- * Global service for strategy operations with execution context injection.
- *
- * Wraps StrategyConnectionService with ExecutionContextService to inject
- * symbol, when, and backtest parameters into the execution context.
- *
- * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
- */
-declare class StrategyGlobalService {
-    private readonly loggerService;
-    private readonly strategyConnectionService;
-    /**
-     * Checks signal status at a specific timestamp.
-     *
-     * Wraps strategy tick() with execution context containing symbol, timestamp,
-     * and backtest mode flag.
-     *
-     * @param symbol - Trading pair symbol
-     * @param when - Timestamp for tick evaluation
-     * @param backtest - Whether running in backtest mode
-     * @returns Discriminated union of tick result (idle, opened, active, closed)
-     */
-    tick: (symbol: string, when: Date, backtest: boolean) => Promise<IStrategyTickResult>;
-    /**
-     * Runs fast backtest against candle array.
-     *
-     * Wraps strategy backtest() with execution context containing symbol,
-     * timestamp, and backtest mode flag.
-     *
-     * @param symbol - Trading pair symbol
-     * @param candles - Array of historical candles to test against
-     * @param when - Starting timestamp for backtest
-     * @param backtest - Whether running in backtest mode (typically true)
-     * @returns Closed signal result with PNL
-     */
-    backtest: (symbol: string, candles: ICandleData[], when: Date, backtest: boolean) => Promise<IStrategyBacktestResult>;
-    /**
-     * Stops the strategy from generating new signals.
-     *
-     * Delegates to StrategyConnectionService.stop() to set internal flag.
-     * Does not require execution context.
-     *
-     * @param strategyName - Name of strategy to stop
-     * @returns Promise that resolves when stop flag is set
-     */
-    stop: (strategyName: StrategyName) => Promise<void>;
-    /**
-     * Clears the memoized ClientStrategy instance from cache.
-     *
-     * Delegates to StrategyConnectionService.clear() to remove strategy from cache.
-     * Forces re-initialization of strategy on next operation.
-     *
-     * @param strategyName - Name of strategy to clear from cache
-     */
-    clear: (strategyName: StrategyName) => Promise<void>;
-}
-
-/**
- * Global service for frame operations.
- *
- * Wraps FrameConnectionService for timeframe generation.
- * Used internally by BacktestLogicPrivateService.
- */
-declare class FrameGlobalService {
-    private readonly loggerService;
-    private readonly frameConnectionService;
-    /**
-     * Generates timeframe array for backtest iteration.
-     *
-     * @param symbol - Trading pair symbol
-     * @returns Promise resolving to array of Date objects
-     */
-    getTimeframe: (symbol: string) => Promise<Date[]>;
-}
-
-/**
- * Service for managing exchange schema registry.
- *
- * Uses ToolRegistry from functools-kit for type-safe schema storage.
- * Exchanges are registered via addExchange() and retrieved by name.
- */
-declare class ExchangeSchemaService {
-    readonly loggerService: LoggerService;
-    private _registry;
-    /**
-     * Registers a new exchange schema.
-     *
-     * @param key - Unique exchange name
-     * @param value - Exchange schema configuration
-     * @throws Error if exchange name already exists
-     */
-    register: (key: ExchangeName, value: IExchangeSchema) => void;
-    /**
-     * Validates exchange schema structure for required properties.
-     *
-     * Performs shallow validation to ensure all required properties exist
-     * and have correct types before registration in the registry.
-     *
-     * @param exchangeSchema - Exchange schema to validate
-     * @throws Error if exchangeName is missing or not a string
-     * @throws Error if getCandles is missing or not a function
-     * @throws Error if formatPrice is missing or not a function
-     * @throws Error if formatQuantity is missing or not a function
-     */
-    private validateShallow;
-    /**
-     * Overrides an existing exchange schema with partial updates.
-     *
-     * @param key - Exchange name to override
-     * @param value - Partial schema updates
-     * @returns Updated exchange schema
-     * @throws Error if exchange name doesn't exist
-     */
-    override: (key: ExchangeName, value: Partial<IExchangeSchema>) => IExchangeSchema;
-    /**
-     * Retrieves an exchange schema by name.
-     *
-     * @param key - Exchange name
-     * @returns Exchange schema configuration
-     * @throws Error if exchange name doesn't exist
-     */
-    get: (key: ExchangeName) => IExchangeSchema;
-}
-
-/**
- * Service for managing strategy schema registry.
- *
- * Uses ToolRegistry from functools-kit for type-safe schema storage.
- * Strategies are registered via addStrategy() and retrieved by name.
- */
-declare class StrategySchemaService {
-    readonly loggerService: LoggerService;
-    private _registry;
-    /**
-     * Registers a new strategy schema.
-     *
-     * @param key - Unique strategy name
-     * @param value - Strategy schema configuration
-     * @throws Error if strategy name already exists
-     */
-    register: (key: StrategyName, value: IStrategySchema) => void;
-    /**
-     * Validates strategy schema structure for required properties.
-     *
-     * Performs shallow validation to ensure all required properties exist
-     * and have correct types before registration in the registry.
-     *
-     * @param strategySchema - Strategy schema to validate
-     * @throws Error if strategyName is missing or not a string
-     * @throws Error if interval is missing or not a valid SignalInterval
-     * @throws Error if getSignal is missing or not a function
-     */
-    private validateShallow;
-    /**
-     * Overrides an existing strategy schema with partial updates.
-     *
-     * @param key - Strategy name to override
-     * @param value - Partial schema updates
-     * @returns Updated strategy schema
-     * @throws Error if strategy name doesn't exist
-     */
-    override: (key: StrategyName, value: Partial<IStrategySchema>) => IStrategySchema;
+    formatPrice: (symbol: string, price: number, when: Date, backtest: boolean) => Promise<string>;
     /**
-     * Retrieves a strategy schema by name.
+     * Formats quantity with execution context.
      *
-     * @param key - Strategy name
-     * @returns Strategy schema configuration
-     * @throws Error if strategy name doesn't exist
+     * @param symbol - Trading pair symbol
+     * @param quantity - Quantity to format
+     * @param when - Timestamp for context
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise resolving to formatted quantity string
      */
-    get: (key: StrategyName) => IStrategySchema;
+    formatQuantity: (symbol: string, quantity: number, when: Date, backtest: boolean) => Promise<string>;
 }
 
 /**
- * Service for managing frame schema registry.
+ * Global service for strategy operations with execution context injection.
  *
- * Uses ToolRegistry from functools-kit for type-safe schema storage.
- * Frames are registered via addFrame() and retrieved by name.
+ * Wraps StrategyConnectionService with ExecutionContextService to inject
+ * symbol, when, and backtest parameters into the execution context.
+ *
+ * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
  */
-declare class FrameSchemaService {
-    readonly loggerService: LoggerService;
-    private _registry;
+declare class StrategyGlobalService {
+    private readonly loggerService;
+    private readonly strategyConnectionService;
     /**
-     * Registers a new frame schema.
+     * Checks signal status at a specific timestamp.
      *
-     * @param key - Unique frame name
-     * @param value - Frame schema configuration
-     * @throws Error if frame name already exists
+     * Wraps strategy tick() with execution context containing symbol, timestamp,
+     * and backtest mode flag.
+     *
+     * @param symbol - Trading pair symbol
+     * @param when - Timestamp for tick evaluation
+     * @param backtest - Whether running in backtest mode
+     * @returns Discriminated union of tick result (idle, opened, active, closed)
      */
-    register(key: FrameName, value: IFrameSchema): void;
+    tick: (symbol: string, when: Date, backtest: boolean) => Promise<IStrategyTickResult>;
     /**
-     * Validates frame schema structure for required properties.
+     * Runs fast backtest against candle array.
      *
-     * Performs shallow validation to ensure all required properties exist
-     * and have correct types before registration in the registry.
+     * Wraps strategy backtest() with execution context containing symbol,
+     * timestamp, and backtest mode flag.
      *
-     * @param frameSchema - Frame schema to validate
-     * @throws Error if frameName is missing or not a string
-     * @throws Error if interval is missing or not a valid FrameInterval
-     * @throws Error if startDate is missing or not a Date
-     * @throws Error if endDate is missing or not a Date
+     * @param symbol - Trading pair symbol
+     * @param candles - Array of historical candles to test against
+     * @param when - Starting timestamp for backtest
+     * @param backtest - Whether running in backtest mode (typically true)
+     * @returns Closed signal result with PNL
      */
-    private validateShallow;
+    backtest: (symbol: string, candles: ICandleData[], when: Date, backtest: boolean) => Promise<IStrategyBacktestResult>;
     /**
-     * Overrides an existing frame schema with partial updates.
+     * Stops the strategy from generating new signals.
      *
-     * @param key - Frame name to override
-     * @param value - Partial schema updates
-     * @throws Error if frame name doesn't exist
+     * Delegates to StrategyConnectionService.stop() to set internal flag.
+     * Does not require execution context.
+     *
+     * @param strategyName - Name of strategy to stop
+     * @returns Promise that resolves when stop flag is set
      */
-    override(key: FrameName, value: Partial<IFrameSchema>): IFrameSchema;
+    stop: (strategyName: StrategyName) => Promise<void>;
     /**
-     * Retrieves a frame schema by name.
+     * Clears the memoized ClientStrategy instance from cache.
      *
-     * @param key - Frame name
-     * @returns Frame schema configuration
-     * @throws Error if frame name doesn't exist
+     * Delegates to StrategyConnectionService.clear() to remove strategy from cache.
+     * Forces re-initialization of strategy on next operation.
+     *
+     * @param strategyName - Name of strategy to clear from cache
      */
-    get(key: FrameName): IFrameSchema;
+    clear: (strategyName: StrategyName) => Promise<void>;
 }
 
 /**
- * Private service for backtest orchestration using async generators.
- *
- * Flow:
- * 1. Get timeframes from frame service
- * 2. Iterate through timeframes calling tick()
- * 3. When signal opens: fetch candles and call backtest()
- * 4. Skip timeframes until signal closes
- * 5. Yield closed result and continue
+ * Global service for frame operations.
  *
- * Memory efficient: streams results without array accumulation.
- * Supports early termination via break in consumer.
+ * Wraps FrameConnectionService for timeframe generation.
+ * Used internally by BacktestLogicPrivateService.
  */
-declare class BacktestLogicPrivateService {
+declare class FrameGlobalService {
     private readonly loggerService;
-    private readonly strategyGlobalService;
-    private readonly exchangeGlobalService;
-    private readonly frameGlobalService;
+    private readonly frameConnectionService;
     /**
-     * Runs backtest for a symbol, streaming closed signals as async generator.
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @yields Closed signal results with PNL
+     * Generates timeframe array for backtest iteration.
      *
-     * @example
-     * ```typescript
-     * for await (const result of backtestLogic.run("BTCUSDT")) {
-     *   console.log(result.closeReason, result.pnl.pnlPercentage);
-     *   if (result.pnl.pnlPercentage < -10) break; // Early termination
-     * }
-     * ```
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to array of Date objects
      */
-    run(symbol: string): AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+    getTimeframe: (symbol: string) => Promise<Date[]>;
 }
 
 /**
- * Private service for live trading orchestration using async generators.
- *
- * Flow:
- * 1. Infinite while(true) loop for continuous monitoring
- * 2. Create real-time date with new Date()
- * 3. Call tick() to check signal status
- * 4. Yield opened/closed results (skip idle/active)
- * 5. Sleep for TICK_TTL between iterations
+ * Service for managing exchange schema registry.
  *
- * Features:
- * - Crash recovery via ClientStrategy.waitForInit()
- * - Real-time progression with new Date()
- * - Memory efficient streaming
- * - Never completes (infinite generator)
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Exchanges are registered via addExchange() and retrieved by name.
  */
-declare class LiveLogicPrivateService {
-    private readonly loggerService;
-    private readonly strategyGlobalService;
+declare class ExchangeSchemaService {
+    readonly loggerService: LoggerService;
+    private _registry;
     /**
-     * Runs live trading for a symbol, streaming results as async generator.
+     * Registers a new exchange schema.
      *
-     * Infinite generator that yields opened and closed signals.
-     * Process can crash and restart - state will be recovered from disk.
+     * @param key - Unique exchange name
+     * @param value - Exchange schema configuration
+     * @throws Error if exchange name already exists
+     */
+    register: (key: ExchangeName, value: IExchangeSchema) => void;
+    /**
+     * Validates exchange schema structure for required properties.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @yields Opened and closed signal results
+     * Performs shallow validation to ensure all required properties exist
+     * and have correct types before registration in the registry.
      *
-     * @example
-     * ```typescript
-     * for await (const result of liveLogic.run("BTCUSDT")) {
-     *   if (result.action === "opened") {
-     *     console.log("New signal:", result.signal.id);
-     *   }
-     *   if (result.action === "closed") {
-     *     console.log("PNL:", result.pnl.pnlPercentage);
-     *   }
-     *   // Infinite loop - will never complete
-     * }
-     * ```
+     * @param exchangeSchema - Exchange schema to validate
+     * @throws Error if exchangeName is missing or not a string
+     * @throws Error if getCandles is missing or not a function
+     * @throws Error if formatPrice is missing or not a function
+     * @throws Error if formatQuantity is missing or not a function
      */
-    run(symbol: string): AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
-}
-
-/**
- * Public service for backtest orchestration with context management.
- *
- * Wraps BacktestLogicPrivateService with MethodContextService to provide
- * implicit context propagation for strategyName, exchangeName, and frameName.
- *
- * This allows getCandles(), getSignal(), and other functions to work without
- * explicit context parameters.
- *
- * @example
- * ```typescript
- * const backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
- *
- * for await (const result of backtestLogicPublicService.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: "1d-backtest",
- * })) {
- *   if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.profit);
- *   }
- * }
- * ```
- */
-declare class BacktestLogicPublicService {
-    private readonly loggerService;
-    private readonly backtestLogicPrivateService;
+    private validateShallow;
     /**
-     * Runs backtest for a symbol with context propagation.
-     *
-     * Streams closed signals as async generator. Context is automatically
-     * injected into all framework functions called during iteration.
+     * Overrides an existing exchange schema with partial updates.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy, exchange, and frame names
-     * @returns Async generator yielding closed signals with PNL
+     * @param key - Exchange name to override
+     * @param value - Partial schema updates
+     * @returns Updated exchange schema
+     * @throws Error if exchange name doesn't exist
      */
-    run: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-        frameName: string;
-    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
-}
-
-/**
- * Public service for live trading orchestration with context management.
- *
- * Wraps LiveLogicPrivateService with MethodContextService to provide
- * implicit context propagation for strategyName and exchangeName.
- *
- * This allows getCandles(), getSignal(), and other functions to work without
- * explicit context parameters.
- *
- * Features:
- * - Infinite async generator (never completes)
- * - Crash recovery via persisted state
- * - Real-time progression with Date.now()
- *
- * @example
- * ```typescript
- * const liveLogicPublicService = inject(TYPES.liveLogicPublicService);
- *
- * // Infinite loop - use Ctrl+C to stop
- * for await (const result of liveLogicPublicService.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- * })) {
- *   if (result.action === "opened") {
- *     console.log("Signal opened:", result.signal);
- *   } else if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.profit);
- *   }
- * }
- * ```
- */
-declare class LiveLogicPublicService {
-    private readonly loggerService;
-    private readonly liveLogicPrivateService;
+    override: (key: ExchangeName, value: Partial<IExchangeSchema>) => IExchangeSchema;
     /**
-     * Runs live trading for a symbol with context propagation.
-     *
-     * Streams opened and closed signals as infinite async generator.
-     * Context is automatically injected into all framework functions.
-     * Process can crash and restart - state will be recovered from disk.
+     * Retrieves an exchange schema by name.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy and exchange names
-     * @returns Infinite async generator yielding opened and closed signals
+     * @param key - Exchange name
+     * @returns Exchange schema configuration
+     * @throws Error if exchange name doesn't exist
      */
-    run: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+    get: (key: ExchangeName) => IExchangeSchema;
 }
 
 /**
- * Global service providing access to live trading functionality.
+ * Service for managing strategy schema registry.
  *
- * Simple wrapper around LiveLogicPublicService for dependency injection.
- * Used by public API exports.
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Strategies are registered via addStrategy() and retrieved by name.
  */
-declare class LiveGlobalService {
-    private readonly loggerService;
-    private readonly liveLogicPublicService;
-    private readonly strategyValidationService;
-    private readonly exchangeValidationService;
+declare class StrategySchemaService {
+    readonly loggerService: LoggerService;
+    private _registry;
     /**
-     * Runs live trading for a symbol with context propagation.
+     * Registers a new strategy schema.
      *
-     * Infinite async generator with crash recovery support.
+     * @param key - Unique strategy name
+     * @param value - Strategy schema configuration
+     * @throws Error if strategy name already exists
+     */
+    register: (key: StrategyName, value: IStrategySchema) => void;
+    /**
+     * Validates strategy schema structure for required properties.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy and exchange names
-     * @returns Infinite async generator yielding opened and closed signals
+     * Performs shallow validation to ensure all required properties exist
+     * and have correct types before registration in the registry.
+     *
+     * @param strategySchema - Strategy schema to validate
+     * @throws Error if strategyName is missing or not a string
+     * @throws Error if interval is missing or not a valid SignalInterval
+     * @throws Error if getSignal is missing or not a function
      */
-    run: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
-}
-
-/**
- * Global service providing access to backtest functionality.
- *
- * Simple wrapper around BacktestLogicPublicService for dependency injection.
- * Used by public API exports.
- */
-declare class BacktestGlobalService {
-    private readonly loggerService;
-    private readonly backtestLogicPublicService;
-    private readonly strategyValidationService;
-    private readonly exchangeValidationService;
-    private readonly frameValidationService;
+    private validateShallow;
     /**
-     * Runs backtest for a symbol with context propagation.
+     * Overrides an existing strategy schema with partial updates.
      *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy, exchange, and frame names
-     * @returns Async generator yielding closed signals with PNL
+     * @param key - Strategy name to override
+     * @param value - Partial schema updates
+     * @returns Updated strategy schema
+     * @throws Error if strategy name doesn't exist
      */
-    run: (symbol: string, context: {
-        strategyName: string;
-        exchangeName: string;
-        frameName: string;
-    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+    override: (key: StrategyName, value: Partial<IStrategySchema>) => IStrategySchema;
+    /**
+     * Retrieves a strategy schema by name.
+     *
+     * @param key - Strategy name
+     * @returns Strategy schema configuration
+     * @throws Error if strategy name doesn't exist
+     */
+    get: (key: StrategyName) => IStrategySchema;
 }
 
 /**
- * Service for generating and saving backtest markdown reports.
- *
- * Features:
- * - Listens to signal events via onTick callback
- * - Accumulates closed signals per strategy using memoized storage
- * - Generates markdown tables with detailed signal information
- * - Saves reports to disk in logs/backtest/{strategyName}.md
- *
- * @example
- * ```typescript
- * const service = new BacktestMarkdownService();
- *
- * // Add to strategy callbacks
- * addStrategy({
- *   strategyName: "my-strategy",
- *   callbacks: {
- *     onTick: (symbol, result, backtest) => {
- *       service.tick(result);
- *     }
- *   }
- * });
+ * Service for managing frame schema registry.
  *
- * // After backtest, generate and save report
- * await service.saveReport("my-strategy");
- * ```
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Frames are registered via addFrame() and retrieved by name.
  */
-declare class BacktestMarkdownService {
-    /** Logger service for debug output */
-    private readonly loggerService;
+declare class FrameSchemaService {
+    readonly loggerService: LoggerService;
+    private _registry;
     /**
-     * Memoized function to get or create ReportStorage for a strategy.
-     * Each strategy gets its own isolated storage instance.
+     * Registers a new frame schema.
+     *
+     * @param key - Unique frame name
+     * @param value - Frame schema configuration
+     * @throws Error if frame name already exists
      */
-    private getStorage;
+    register(key: FrameName, value: IFrameSchema): void;
     /**
-     * Processes tick events and accumulates closed signals.
-     * Should be called from IStrategyCallbacks.onTick.
-     *
-     * Only processes closed signals - opened signals are ignored.
-     *
-     * @param data - Tick result from strategy execution (opened or closed)
+     * Validates frame schema structure for required properties.
      *
-     * @example
-     * ```typescript
-     * const service = new BacktestMarkdownService();
+     * Performs shallow validation to ensure all required properties exist
+     * and have correct types before registration in the registry.
      *
-     * callbacks: {
-     *   onTick: (symbol, result, backtest) => {
-     *     service.tick(result);
-     *   }
-     * }
-     * ```
+     * @param frameSchema - Frame schema to validate
+     * @throws Error if frameName is missing or not a string
+     * @throws Error if interval is missing or not a valid FrameInterval
+     * @throws Error if startDate is missing or not a Date
+     * @throws Error if endDate is missing or not a Date
      */
-    private tick;
+    private validateShallow;
     /**
-     * Generates markdown report with all closed signals for a strategy.
-     * Delegates to ReportStorage.generateReport().
+     * Overrides an existing frame schema with partial updates.
      *
-     * @param strategyName - Strategy name to generate report for
-     * @returns Markdown formatted report string with table of all closed signals
+     * @param key - Frame name to override
+     * @param value - Partial schema updates
+     * @throws Error if frame name doesn't exist
+     */
+    override(key: FrameName, value: Partial<IFrameSchema>): IFrameSchema;
+    /**
+     * Retrieves a frame schema by name.
      *
-     * @example
-     * ```typescript
-     * const service = new BacktestMarkdownService();
-     * const markdown = service.generateReport("my-strategy");
-     * console.log(markdown);
-     * ```
+     * @param key - Frame name
+     * @returns Frame schema configuration
+     * @throws Error if frame name doesn't exist
      */
-    getReport: (strategyName: StrategyName) => Promise<string>;
+    get(key: FrameName): IFrameSchema;
+}
+
+/**
+ * Private service for backtest orchestration using async generators.
+ *
+ * Flow:
+ * 1. Get timeframes from frame service
+ * 2. Iterate through timeframes calling tick()
+ * 3. When signal opens: fetch candles and call backtest()
+ * 4. Skip timeframes until signal closes
+ * 5. Yield closed result and continue
+ *
+ * Memory efficient: streams results without array accumulation.
+ * Supports early termination via break in consumer.
+ */
+declare class BacktestLogicPrivateService {
+    private readonly loggerService;
+    private readonly strategyGlobalService;
+    private readonly exchangeGlobalService;
+    private readonly frameGlobalService;
+    private readonly methodContextService;
     /**
-     * Saves strategy report to disk.
-     * Creates directory if it doesn't exist.
-     * Delegates to ReportStorage.dump().
+     * Runs backtest for a symbol, streaming closed signals as async generator.
      *
-     * @param strategyName - Strategy name to save report for
-     * @param path - Directory path to save report (default: "./logs/backtest")
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @yields Closed signal results with PNL
      *
      * @example
      * ```typescript
-     * const service = new BacktestMarkdownService();
-     *
-     * // Save to default path: ./logs/backtest/my-strategy.md
-     * await service.dump("my-strategy");
-     *
-     * // Save to custom path: ./custom/path/my-strategy.md
-     * await service.dump("my-strategy", "./custom/path");
+     * for await (const result of backtestLogic.run("BTCUSDT")) {
+     *   console.log(result.closeReason, result.pnl.pnlPercentage);
+     *   if (result.pnl.pnlPercentage < -10) break; // Early termination
+     * }
      * ```
      */
-    dump: (strategyName: StrategyName, path?: string) => Promise<void>;
+    run(symbol: string): AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+}
+
+/**
+ * Private service for live trading orchestration using async generators.
+ *
+ * Flow:
+ * 1. Infinite while(true) loop for continuous monitoring
+ * 2. Create real-time date with new Date()
+ * 3. Call tick() to check signal status
+ * 4. Yield opened/closed results (skip idle/active)
+ * 5. Sleep for TICK_TTL between iterations
+ *
+ * Features:
+ * - Crash recovery via ClientStrategy.waitForInit()
+ * - Real-time progression with new Date()
+ * - Memory efficient streaming
+ * - Never completes (infinite generator)
+ */
+declare class LiveLogicPrivateService {
+    private readonly loggerService;
+    private readonly strategyGlobalService;
     /**
-     * Clears accumulated 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
-     * const service = new BacktestMarkdownService();
+     * Runs live trading for a symbol, streaming results as async generator.
      *
-     * // Clear specific strategy data
-     * await service.clear("my-strategy");
+     * Infinite generator that yields opened and closed signals.
+     * Process can crash and restart - state will be recovered from disk.
      *
-     * // Clear all strategies' data
-     * await service.clear();
-     * ```
-     */
-    clear: (strategyName?: StrategyName) => Promise<void>;
-    /**
-     * Initializes the service by subscribing to backtest signal events.
-     * Uses singleshot to ensure initialization happens only once.
-     * Automatically called on first use.
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @yields Opened and closed signal results
      *
      * @example
      * ```typescript
-     * const service = new BacktestMarkdownService();
-     * await service.init(); // Subscribe to backtest events
+     * for await (const result of liveLogic.run("BTCUSDT")) {
+     *   if (result.action === "opened") {
+     *     console.log("New signal:", result.signal.id);
+     *   }
+     *   if (result.action === "closed") {
+     *     console.log("PNL:", result.pnl.pnlPercentage);
+     *   }
+     *   // Infinite loop - will never complete
+     * }
      * ```
      */
-    protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    run(symbol: string): AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
 }
 
 /**
- * Service for generating and saving live trading markdown reports.
+ * Public service for backtest orchestration with context management.
  *
- * Features:
- * - Listens to all signal events via onTick callback
- * - Accumulates all events (idle, opened, active, closed) per strategy
- * - Generates markdown tables with detailed event information
- * - Provides trading statistics (win rate, average PNL)
- * - Saves reports to disk in logs/live/{strategyName}.md
+ * Wraps BacktestLogicPrivateService with MethodContextService to provide
+ * implicit context propagation for strategyName, exchangeName, and frameName.
+ *
+ * This allows getCandles(), getSignal(), and other functions to work without
+ * explicit context parameters.
  *
  * @example
  * ```typescript
- * const service = new LiveMarkdownService();
+ * const backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
  *
- * // Add to strategy callbacks
- * addStrategy({
+ * for await (const result of backtestLogicPublicService.run("BTCUSDT", {
  *   strategyName: "my-strategy",
- *   callbacks: {
- *     onTick: (symbol, result, backtest) => {
- *       if (!backtest) {
- *         service.tick(result);
- *       }
- *     }
+ *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest",
+ * })) {
+ *   if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.profit);
  *   }
- * });
- *
- * // Later: generate and save report
- * await service.dump("my-strategy");
+ * }
  * ```
  */
-declare class LiveMarkdownService {
-    /** Logger service for debug output */
+declare class BacktestLogicPublicService {
     private readonly loggerService;
+    private readonly backtestLogicPrivateService;
     /**
-     * Memoized function to get or create ReportStorage for a strategy.
-     * Each strategy gets its own isolated storage instance.
-     */
-    private getStorage;
-    /**
-     * Processes tick events and accumulates all event types.
-     * Should be called from IStrategyCallbacks.onTick.
-     *
-     * Processes all event types: idle, opened, active, closed.
-     *
-     * @param data - Tick result from strategy execution
-     *
-     * @example
-     * ```typescript
-     * const service = new LiveMarkdownService();
-     *
-     * callbacks: {
-     *   onTick: (symbol, result, backtest) => {
-     *     if (!backtest) {
-     *       service.tick(result);
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    private tick;
-    /**
-     * Generates markdown report with all events for a strategy.
-     * Delegates to ReportStorage.getReport().
+     * Runs backtest for a symbol with context propagation.
      *
-     * @param strategyName - Strategy name to generate report for
-     * @returns Markdown formatted report string with table of all events
+     * Streams closed signals as async generator. Context is automatically
+     * injected into all framework functions called during iteration.
      *
-     * @example
-     * ```typescript
-     * const service = new LiveMarkdownService();
-     * const markdown = await service.getReport("my-strategy");
-     * console.log(markdown);
-     * ```
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Async generator yielding closed signals with PNL
      */
-    getReport: (strategyName: StrategyName) => Promise<string>;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+}
+
+/**
+ * Public service for live trading orchestration with context management.
+ *
+ * Wraps LiveLogicPrivateService with MethodContextService to provide
+ * implicit context propagation for strategyName and exchangeName.
+ *
+ * This allows getCandles(), getSignal(), and other functions to work without
+ * explicit context parameters.
+ *
+ * Features:
+ * - Infinite async generator (never completes)
+ * - Crash recovery via persisted state
+ * - Real-time progression with Date.now()
+ *
+ * @example
+ * ```typescript
+ * const liveLogicPublicService = inject(TYPES.liveLogicPublicService);
+ *
+ * // Infinite loop - use Ctrl+C to stop
+ * for await (const result of liveLogicPublicService.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ * })) {
+ *   if (result.action === "opened") {
+ *     console.log("Signal opened:", result.signal);
+ *   } else if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.profit);
+ *   }
+ * }
+ * ```
+ */
+declare class LiveLogicPublicService {
+    private readonly loggerService;
+    private readonly liveLogicPrivateService;
     /**
-     * Saves strategy report to disk.
-     * Creates directory if it doesn't exist.
-     * Delegates to ReportStorage.dump().
-     *
-     * @param strategyName - Strategy name to save report for
-     * @param path - Directory path to save report (default: "./logs/live")
-     *
-     * @example
-     * ```typescript
-     * const service = new LiveMarkdownService();
+     * Runs live trading for a symbol with context propagation.
      *
-     * // Save to default path: ./logs/live/my-strategy.md
-     * await service.dump("my-strategy");
+     * Streams opened and closed signals as infinite async generator.
+     * Context is automatically injected into all framework functions.
+     * Process can crash and restart - state will be recovered from disk.
      *
-     * // Save to custom path: ./custom/path/my-strategy.md
-     * await service.dump("my-strategy", "./custom/path");
-     * ```
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy and exchange names
+     * @returns Infinite async generator yielding opened and closed signals
      */
-    dump: (strategyName: StrategyName, path?: string) => Promise<void>;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+}
+
+/**
+ * Global service providing access to live trading functionality.
+ *
+ * Simple wrapper around LiveLogicPublicService for dependency injection.
+ * Used by public API exports.
+ */
+declare class LiveGlobalService {
+    private readonly loggerService;
+    private readonly liveLogicPublicService;
+    private readonly strategyValidationService;
+    private readonly exchangeValidationService;
     /**
-     * Clears accumulated event 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
-     * const service = new LiveMarkdownService();
+     * Runs live trading for a symbol with context propagation.
      *
-     * // Clear specific strategy data
-     * await service.clear("my-strategy");
+     * Infinite async generator with crash recovery support.
      *
-     * // Clear all strategies' data
-     * await service.clear();
-     * ```
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy and exchange names
+     * @returns Infinite async generator yielding opened and closed signals
      */
-    clear: (strategyName?: StrategyName) => Promise<void>;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+}
+
+/**
+ * Global service providing access to backtest functionality.
+ *
+ * Simple wrapper around BacktestLogicPublicService for dependency injection.
+ * Used by public API exports.
+ */
+declare class BacktestGlobalService {
+    private readonly loggerService;
+    private readonly backtestLogicPublicService;
+    private readonly strategyValidationService;
+    private readonly exchangeValidationService;
+    private readonly frameValidationService;
     /**
-     * Initializes the service by subscribing to live signal events.
-     * Uses singleshot to ensure initialization happens only once.
-     * Automatically called on first use.
+     * Runs backtest for a symbol with context propagation.
      *
-     * @example
-     * ```typescript
-     * const service = new LiveMarkdownService();
-     * await service.init(); // Subscribe to live events
-     * ```
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Async generator yielding closed signals with PNL
      */
-    protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
 }
 
 /**
@@ -2642,6 +2980,12 @@ declare class ExchangeValidationService {
      * Memoized function to cache validation results
      */
     validate: (exchangeName: ExchangeName, source: string) => void;
+    /**
+     * Returns a list of all registered exchange schemas
+     * @public
+     * @returns Array of exchange schemas with their configurations
+     */
+    list: () => Promise<IExchangeSchema[]>;
 }
 
 /**
@@ -2673,6 +3017,12 @@ declare class StrategyValidationService {
      * Memoized function to cache validation results
      */
     validate: (strategyName: StrategyName, source: string) => void;
+    /**
+     * Returns a list of all registered strategy schemas
+     * @public
+     * @returns Array of strategy schemas with their configurations
+     */
+    list: () => Promise<IStrategySchema[]>;
 }
 
 /**
@@ -2704,6 +3054,12 @@ declare class FrameValidationService {
      * Memoized function to cache validation results
      */
     validate: (frameName: FrameName, source: string) => void;
+    /**
+     * Returns a list of all registered frame schemas
+     * @public
+     * @returns Array of frame schemas with their configurations
+     */
+    list: () => Promise<IFrameSchema[]>;
 }
 
 declare const backtest: {
@@ -2736,4 +3092,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { Backtest, type CandleInterval, type EntityId, ExecutionContextService, type FrameInterval, type ICandleData, type IExchangeSchema, type IFrameSchema, type IPersistBase, type ISignalData, type ISignalDto, type ISignalRow, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, Live, MethodContextService, PersistBase, PersistSignalAdaper, type SignalInterval, type TPersistBase, type TPersistBaseCtor, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listenDone, listenDoneOnce, listenError, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };
+export { Backtest, type BacktestStatistics, type CandleInterval, type DoneContract, type EntityId, ExecutionContextService, type FrameInterval, type ICandleData, type IExchangeSchema, type IFrameSchema, type IPersistBase, type ISignalData, type ISignalDto, type ISignalRow, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, Live, type LiveStatistics, MethodContextService, PersistBase, PersistSignalAdaper, type ProgressContract, type SignalInterval, type TPersistBase, type TPersistBaseCtor, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listStrategies, listenDone, listenDoneOnce, listenError, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };