backtest-kit 1.9.1 → 1.10.2

package/types.d.ts

@@ -215,166 +215,91 @@ declare function partialLoss(symbol: string, percentToClose: number): Promise<vo
  *
  * @param symbol - Trading pair symbol
  * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+ * @param currentPrice - Current market price to check for intrusion
  * @returns Promise that resolves when trailing SL is updated
  *
  * @example
  * ```typescript
  * import { trailingStop } from "backtest-kit";
  *
- * // LONG: entry=100, originalSL=90, distance=10
- * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
- * await trailingStop("BTCUSDT", -50);
+ * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+ * // Tighten stop by 50%: newSL = 100 - 5% = 95
+ * await trailingStop("BTCUSDT", -50, 102);
  * ```
  */
-declare function trailingStop(symbol: string, percentShift: number): Promise<void>;
-
-declare const GLOBAL_CONFIG: {
-    /**
-     * Time to wait for scheduled signal to activate (in minutes)
-     * If signal does not activate within this time, it will be cancelled.
-     */
-    CC_SCHEDULE_AWAIT_MINUTES: number;
-    /**
-     * Number of candles to use for average price calculation (VWAP)
-     * Default: 5 candles (last 5 minutes when using 1m interval)
-     */
-    CC_AVG_PRICE_CANDLES_COUNT: number;
-    /**
-     * Slippage percentage applied to entry and exit prices.
-     * Simulates market impact and order book depth.
-     * Applied twice (entry and exit) for realistic execution simulation.
-     * Default: 0.1% per transaction
-     */
-    CC_PERCENT_SLIPPAGE: number;
-    /**
-     * Fee percentage charged per transaction.
-     * Applied twice (entry and exit) for total fee calculation.
-     * Default: 0.1% per transaction (total 0.2%)
-     */
-    CC_PERCENT_FEE: number;
-    /**
-     * Minimum TakeProfit distance from priceOpen (percentage)
-     * Must be greater than (slippage + fees) to ensure profitable trades
-     *
-     * Calculation:
-     * - Slippage effect: ~0.2% (0.1% × 2 transactions)
-     * - Fees: 0.2% (0.1% × 2 transactions)
-     * - Minimum profit buffer: 0.1%
-     * - Total: 0.5%
-     *
-     * Default: 0.5% (covers all costs + minimum profit margin)
-     */
-    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: number;
-    /**
-     * Minimum StopLoss distance from priceOpen (percentage)
-     * Prevents signals from being immediately stopped out due to price volatility
-     * Default: 0.5% (buffer to avoid instant stop loss on normal market fluctuations)
-     */
-    CC_MIN_STOPLOSS_DISTANCE_PERCENT: number;
-    /**
-     * Maximum StopLoss distance from priceOpen (percentage)
-     * Prevents catastrophic losses from extreme StopLoss values
-     * Default: 20% (one signal cannot lose more than 20% of position)
-     */
-    CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
-    /**
-     * Maximum signal lifetime in minutes
-     * Prevents eternal signals that block risk limits for weeks/months
-     * Default: 1440 minutes (1 day)
-     */
-    CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
-    /**
-     * Maximum time allowed for signal generation (in seconds).
-     * Prevents long-running or stuck signal generation routines from blocking
-     * execution or consuming resources indefinitely. If generation exceeds this
-     * threshold the attempt should be aborted, logged and optionally retried.
-     *
-     * Default: 180 seconds (3 minutes)
-     */
-    CC_MAX_SIGNAL_GENERATION_SECONDS: number;
-    /**
-     * Number of retries for getCandles function
-     * Default: 3 retries
-     */
-    CC_GET_CANDLES_RETRY_COUNT: number;
-    /**
-     * Delay between retries for getCandles function (in milliseconds)
-     * Default: 5000 ms (5 seconds)
-     */
-    CC_GET_CANDLES_RETRY_DELAY_MS: number;
-    /**
-     * Maximum allowed deviation factor for price anomaly detection.
-     * Price should not be more than this factor lower than reference price.
-     *
-     * Reasoning:
-     * - Incomplete candles from Binance API typically have prices near 0 (e.g., $0.01-1)
-     * - Normal BTC price ranges: $20,000-100,000
-     * - Factor 1000 catches prices below $20-100 when median is $20,000-100,000
-     * - Factor 100 would be too permissive (allows $200 when median is $20,000)
-     * - Factor 10000 might be too strict for low-cap altcoins
-     *
-     * Example: BTC at $50,000 median → threshold $50 (catches $0.01-1 anomalies)
-     */
-    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: number;
-    /**
-     * Minimum number of candles required for reliable median calculation.
-     * Below this threshold, use simple average instead of median.
-     *
-     * Reasoning:
-     * - Each candle provides 4 price points (OHLC)
-     * - 5 candles = 20 price points, sufficient for robust median calculation
-     * - Below 5 candles, single anomaly can heavily skew median
-     * - Statistical rule of thumb: minimum 7-10 data points for median stability
-     * - Average is more stable than median for small datasets (n < 20)
-     *
-     * Example: 3 candles = 12 points (use average), 5 candles = 20 points (use median)
-     */
-    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: number;
-    /**
-     * Controls visibility of signal notes in markdown report tables.
-     * When enabled, the "Note" column will be displayed in all markdown reports
-     * (backtest, live, schedule, risk, etc.)
-     *
-     * Default: false (notes are hidden to reduce table width and improve readability)
-     */
-    CC_REPORT_SHOW_SIGNAL_NOTE: boolean;
-};
+declare function trailingStop(symbol: string, percentShift: number, currentPrice: number): Promise<void>;
 /**
- * Type for global configuration object.
+ * Moves stop-loss to breakeven when price reaches threshold.
+ *
+ * Moves SL to entry price (zero-risk position) when current price has moved
+ * far enough in profit direction to cover transaction costs.
+ * Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<boolean> - true if breakeven was set, false if conditions not met
+ *
+ * @example
+ * ```typescript
+ * import { breakeven } from "backtest-kit";
+ *
+ * // LONG: entry=100, slippage=0.1%, fee=0.1%, threshold=0.4%
+ * // Try to move SL to breakeven (activates when price >= 100.4)
+ * const moved = await breakeven("BTCUSDT");
+ * if (moved) {
+ *   console.log("Position moved to breakeven!");
+ * }
+ * ```
  */
-type GlobalConfig = typeof GLOBAL_CONFIG;
+declare function breakeven(symbol: string): Promise<boolean>;
 
 /**
- * Mapping of available table/markdown reports to their column definitions.
+ * Execution context containing runtime parameters for strategy/exchange operations.
  *
- * Each property references a column definition object imported from
- * `src/assets/*.columns`. These are used by markdown/report generators
- * (backtest, live, schedule, risk, heat, performance, partial, walker).
+ * Propagated through ExecutionContextService to provide implicit context
+ * for getCandles(), tick(), backtest() and other operations.
  */
-declare const COLUMN_CONFIG: {
-    /** Columns used in backtest markdown tables and reports */
-    backtest_columns: ColumnModel<IStrategyTickResultClosed>[];
-    /** Columns used by heatmap / heat reports */
-    heat_columns: ColumnModel<IHeatmapRow>[];
-    /** Columns for live trading reports and logs */
-    live_columns: ColumnModel<TickEvent>[];
-    /** Columns for partial-results / incremental reports */
-    partial_columns: ColumnModel<PartialEvent>[];
-    /** Columns for performance summary reports */
-    performance_columns: ColumnModel<MetricStats>[];
-    /** Columns for risk-related reports */
-    risk_columns: ColumnModel<RiskEvent>[];
-    /** Columns for scheduled report output */
-    schedule_columns: ColumnModel<ScheduledEvent>[];
-    /** Walker: PnL summary columns */
-    walker_pnl_columns: ColumnModel<SignalData$1>[];
-    /** Walker: strategy-level summary columns */
-    walker_strategy_columns: ColumnModel<IStrategyResult>[];
-};
+interface IExecutionContext {
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Current timestamp for operation */
+    when: Date;
+    /** Whether running in backtest mode (true) or live mode (false) */
+    backtest: boolean;
+}
 /**
- * Type for the column configuration object.
+ * Scoped service for execution context propagation.
+ *
+ * Uses di-scoped for implicit context passing without explicit parameters.
+ * Context includes symbol, when (timestamp), and backtest flag.
+ *
+ * Used by GlobalServices to inject context into operations.
+ *
+ * @example
+ * ```typescript
+ * ExecutionContextService.runInContext(
+ *   async () => {
+ *     // Inside this callback, context is automatically available
+ *     return await someOperation();
+ *   },
+ *   { symbol: "BTCUSDT", when: new Date(), backtest: true }
+ * );
+ * ```
  */
-type ColumnConfig = typeof COLUMN_CONFIG;
+declare const ExecutionContextService: (new () => {
+    readonly context: IExecutionContext;
+}) & Omit<{
+    new (context: IExecutionContext): {
+        readonly context: IExecutionContext;
+    };
+}, "prototype"> & di_scoped.IScopedClassRun<[context: IExecutionContext]>;
+/**
+ * Type helper for ExecutionContextService instance.
+ * Used for dependency injection type annotations.
+ */
+type TExecutionContextService = InstanceType<typeof ExecutionContextService>;
 
 /**
  * Interface representing a logging mechanism for the swarm system.
@@ -405,244 +330,30 @@ interface ILogger {
 }
 
 /**
- * Sets custom logger implementation for the framework.
- *
- * All log messages from internal services will be forwarded to the provided logger
- * with automatic context injection (strategyName, exchangeName, symbol, etc.).
- *
- * @param logger - Custom logger implementing ILogger interface
- *
- * @example
- * ```typescript
- * setLogger({
- *   log: (topic, ...args) => console.log(topic, args),
- *   debug: (topic, ...args) => console.debug(topic, args),
- *   info: (topic, ...args) => console.info(topic, args),
- * });
- * ```
+ * Candle time interval for fetching historical data.
  */
-declare function setLogger(logger: ILogger): void;
+type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h";
 /**
- * Sets global configuration parameters for the framework.
- * @param config - Partial configuration object to override default settings
- * @param _unsafe - Skip config validations - required for testbed
- *
- * @example
- * ```typescript
- * setConfig({
- *   CC_SCHEDULE_AWAIT_MINUTES: 90,
- * });
- * ```
+ * Single OHLCV candle data point.
+ * Used for VWAP calculation and backtesting.
  */
-declare function setConfig(config: Partial<GlobalConfig>, _unsafe?: boolean): void;
+interface ICandleData {
+    /** Unix timestamp in milliseconds when candle opened */
+    timestamp: number;
+    /** Opening price at candle start */
+    open: number;
+    /** Highest price during candle period */
+    high: number;
+    /** Lowest price during candle period */
+    low: number;
+    /** Closing price at candle end */
+    close: number;
+    /** Trading volume during candle period */
+    volume: number;
+}
 /**
- * Retrieves a copy of the current global configuration.
- *
- * Returns a shallow copy of the current GLOBAL_CONFIG to prevent accidental mutations.
- * Use this to inspect the current configuration state without modifying it.
- *
- * @returns {GlobalConfig} A copy of the current global configuration object
- *
- * @example
- * ```typescript
- * const currentConfig = getConfig();
- * console.log(currentConfig.CC_SCHEDULE_AWAIT_MINUTES);
- * ```
- */
-declare function getConfig(): {
-    CC_SCHEDULE_AWAIT_MINUTES: number;
-    CC_AVG_PRICE_CANDLES_COUNT: number;
-    CC_PERCENT_SLIPPAGE: number;
-    CC_PERCENT_FEE: number;
-    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: number;
-    CC_MIN_STOPLOSS_DISTANCE_PERCENT: number;
-    CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
-    CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
-    CC_MAX_SIGNAL_GENERATION_SECONDS: number;
-    CC_GET_CANDLES_RETRY_COUNT: number;
-    CC_GET_CANDLES_RETRY_DELAY_MS: number;
-    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: number;
-    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: number;
-    CC_REPORT_SHOW_SIGNAL_NOTE: boolean;
-};
-/**
- * Retrieves the default configuration object for the framework.
- *
- * Returns a reference to the default configuration with all preset values.
- * Use this to see what configuration options are available and their default values.
- *
- * @returns {GlobalConfig} The default configuration object
- *
- * @example
- * ```typescript
- * const defaultConfig = getDefaultConfig();
- * console.log(defaultConfig.CC_SCHEDULE_AWAIT_MINUTES);
- * ```
- */
-declare function getDefaultConfig(): Readonly<{
-    CC_SCHEDULE_AWAIT_MINUTES: number;
-    CC_AVG_PRICE_CANDLES_COUNT: number;
-    CC_PERCENT_SLIPPAGE: number;
-    CC_PERCENT_FEE: number;
-    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: number;
-    CC_MIN_STOPLOSS_DISTANCE_PERCENT: number;
-    CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
-    CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
-    CC_MAX_SIGNAL_GENERATION_SECONDS: number;
-    CC_GET_CANDLES_RETRY_COUNT: number;
-    CC_GET_CANDLES_RETRY_DELAY_MS: number;
-    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: number;
-    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: number;
-    CC_REPORT_SHOW_SIGNAL_NOTE: boolean;
-}>;
-/**
- * Sets custom column configurations for markdown report generation.
- *
- * Allows overriding default column definitions for any report type.
- * All columns are validated before assignment to ensure structural correctness.
- *
- * @param columns - Partial column configuration object to override default column settings
- * @param _unsafe - Skip column validations - required for testbed
- *
- * @example
- * ```typescript
- * setColumns({
- *   backtest_columns: [
- *     {
- *       key: "customId",
- *       label: "Custom ID",
- *       format: (data) => data.signal.id,
- *       isVisible: () => true
- *     }
- *   ],
- * });
- * ```
- *
- * @throws {Error} If column configuration is invalid
- */
-declare function setColumns(columns: Partial<ColumnConfig>, _unsafe?: boolean): void;
-/**
- * Retrieves a copy of the current column configuration for markdown report generation.
- *
- * Returns a shallow copy of the current COLUMN_CONFIG to prevent accidental mutations.
- * Use this to inspect the current column definitions without modifying them.
- *
- * @returns {ColumnConfig} A copy of the current column configuration object
- *
- * @example
- * ```typescript
- * const currentColumns = getColumns();
- * console.log(currentColumns.backtest_columns.length);
- * ```
- */
-declare function getColumns(): {
-    backtest_columns: ColumnModel<IStrategyTickResultClosed>[];
-    heat_columns: ColumnModel<IHeatmapRow>[];
-    live_columns: ColumnModel<TickEvent>[];
-    partial_columns: ColumnModel<PartialEvent>[];
-    performance_columns: ColumnModel<MetricStats>[];
-    risk_columns: ColumnModel<RiskEvent>[];
-    schedule_columns: ColumnModel<ScheduledEvent>[];
-    walker_pnl_columns: ColumnModel<SignalData$1>[];
-    walker_strategy_columns: ColumnModel<IStrategyResult>[];
-};
-/**
- * Retrieves the default column configuration object for markdown report generation.
- *
- * Returns a reference to the default column definitions with all preset values.
- * Use this to see what column options are available and their default definitions.
- *
- * @returns {ColumnConfig} The default column configuration object
- *
- * @example
- * ```typescript
- * const defaultColumns = getDefaultColumns();
- * console.log(defaultColumns.backtest_columns);
- * ```
- */
-declare function getDefaultColumns(): Readonly<{
-    backtest_columns: ColumnModel<IStrategyTickResultClosed>[];
-    heat_columns: ColumnModel<IHeatmapRow>[];
-    live_columns: ColumnModel<TickEvent>[];
-    partial_columns: ColumnModel<PartialEvent>[];
-    performance_columns: ColumnModel<MetricStats>[];
-    risk_columns: ColumnModel<RiskEvent>[];
-    schedule_columns: ColumnModel<ScheduledEvent>[];
-    walker_pnl_columns: ColumnModel<SignalData$1>[];
-    walker_strategy_columns: ColumnModel<IStrategyResult>[];
-}>;
-
-/**
- * Execution context containing runtime parameters for strategy/exchange operations.
- *
- * Propagated through ExecutionContextService to provide implicit context
- * for getCandles(), tick(), backtest() and other operations.
- */
-interface IExecutionContext {
-    /** Trading pair symbol (e.g., "BTCUSDT") */
-    symbol: string;
-    /** Current timestamp for operation */
-    when: Date;
-    /** Whether running in backtest mode (true) or live mode (false) */
-    backtest: boolean;
-}
-/**
- * Scoped service for execution context propagation.
- *
- * Uses di-scoped for implicit context passing without explicit parameters.
- * Context includes symbol, when (timestamp), and backtest flag.
- *
- * Used by GlobalServices to inject context into operations.
- *
- * @example
- * ```typescript
- * ExecutionContextService.runInContext(
- *   async () => {
- *     // Inside this callback, context is automatically available
- *     return await someOperation();
- *   },
- *   { symbol: "BTCUSDT", when: new Date(), backtest: true }
- * );
- * ```
- */
-declare const ExecutionContextService: (new () => {
-    readonly context: IExecutionContext;
-}) & Omit<{
-    new (context: IExecutionContext): {
-        readonly context: IExecutionContext;
-    };
-}, "prototype"> & di_scoped.IScopedClassRun<[context: IExecutionContext]>;
-/**
- * Type helper for ExecutionContextService instance.
- * Used for dependency injection type annotations.
- */
-type TExecutionContextService = InstanceType<typeof ExecutionContextService>;
-
-/**
- * Candle time interval for fetching historical data.
- */
-type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h";
-/**
- * Single OHLCV candle data point.
- * Used for VWAP calculation and backtesting.
- */
-interface ICandleData {
-    /** Unix timestamp in milliseconds when candle opened */
-    timestamp: number;
-    /** Opening price at candle start */
-    open: number;
-    /** Highest price during candle period */
-    high: number;
-    /** Lowest price during candle period */
-    low: number;
-    /** Closing price at candle end */
-    close: number;
-    /** Trading volume during candle period */
-    volume: number;
-}
-/**
- * Exchange parameters passed to ClientExchange constructor.
- * Combines schema with runtime dependencies.
+ * Exchange parameters passed to ClientExchange constructor.
+ * Combines schema with runtime dependencies.
  */
 interface IExchangeParams extends IExchangeSchema {
     /** Logger service for debug output */
@@ -987,6 +698,8 @@ interface IRiskSchema {
  * Combines schema with runtime dependencies and emission callbacks.
  */
 interface IRiskParams extends IRiskSchema {
+    /** Exchange name (e.g., "binance") */
+    exchangeName: ExchangeName;
     /** Logger service for debug output */
     logger: ILogger;
     /** True if backtest mode, false if live mode */
@@ -1203,6 +916,112 @@ interface IPartial {
     clear(symbol: string, data: IPublicSignalRow, priceClose: number, backtest: boolean): Promise<void>;
 }
 
+/**
+ * Serializable breakeven data for persistence layer.
+ * Converts state to simple boolean for JSON serialization.
+ *
+ * Stored in PersistBreakevenAdapter as Record<signalId, IBreakevenData>.
+ * Loaded on initialization and converted back to IBreakevenState.
+ */
+interface IBreakevenData {
+    /**
+     * Whether breakeven has been reached for this signal.
+     * Serialized form of IBreakevenState.reached.
+     */
+    reached: boolean;
+}
+/**
+ * Breakeven tracking interface.
+ * Implemented by ClientBreakeven and BreakevenConnectionService.
+ *
+ * Tracks when a signal's stop-loss is moved to breakeven (entry price).
+ * Emits events when threshold is reached (price moves far enough to cover transaction costs).
+ *
+ * @example
+ * ```typescript
+ * import { ClientBreakeven } from "./client/ClientBreakeven";
+ *
+ * const breakeven = new ClientBreakeven({
+ *   logger: loggerService,
+ *   onBreakeven: (symbol, data, price, backtest, timestamp) => {
+ *     console.log(`Signal ${data.id} reached breakeven at ${price}`);
+ *   }
+ * });
+ *
+ * await breakeven.waitForInit("BTCUSDT");
+ *
+ * // During signal monitoring
+ * await breakeven.check("BTCUSDT", signal, 100.5, false, new Date());
+ * // Emits event when threshold reached and SL moved to entry
+ *
+ * // When signal closes
+ * await breakeven.clear("BTCUSDT", signal, 101, false);
+ * ```
+ */
+interface IBreakeven {
+    /**
+     * Checks if breakeven should be triggered and emits event if conditions met.
+     *
+     * Called by ClientStrategy during signal monitoring.
+     * Checks if:
+     * 1. Breakeven not already reached
+     * 2. Price has moved far enough to cover transaction costs
+     * 3. Stop-loss can be moved to entry price
+     *
+     * If all conditions met:
+     * - Marks breakeven as reached
+     * - Calls onBreakeven callback (emits to breakevenSubject)
+     * - Persists state to disk
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param backtest - True if backtest mode, false if live mode
+     * @param when - Event timestamp (current time for live, candle time for backtest)
+     * @returns Promise that resolves when breakeven check is complete
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, slippage=0.1%, fee=0.1%, threshold=0.4%
+     * // Price at 100.3 - threshold not reached
+     * await breakeven.check("BTCUSDT", signal, 100.3, false, new Date());
+     * // No event emitted (price < 100.4)
+     *
+     * // Price at 100.5 - threshold reached!
+     * await breakeven.check("BTCUSDT", signal, 100.5, false, new Date());
+     * // Emits breakevenSubject event
+     *
+     * // Price at 101 - already at breakeven
+     * await breakeven.check("BTCUSDT", signal, 101, false, new Date());
+     * // No event emitted (already reached)
+     * ```
+     */
+    check(symbol: string, data: IPublicSignalRow, currentPrice: number, backtest: boolean, when: Date): Promise<boolean>;
+    /**
+     * Clears breakeven state when signal closes.
+     *
+     * Called by ClientStrategy when signal completes (TP/SL/time_expired).
+     * Removes signal state from memory and persists changes to disk.
+     * Cleans up memoized ClientBreakeven instance in BreakevenConnectionService.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param priceClose - Final closing price
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Promise that resolves when clear is complete
+     *
+     * @example
+     * ```typescript
+     * // Signal closes at take profit
+     * await breakeven.clear("BTCUSDT", signal, 101);
+     * // State removed from _states Map
+     * // Persisted to disk without this signal's data
+     * // Memoized instance cleared from getBreakeven cache
+     * ```
+     */
+    clear(symbol: string, data: IPublicSignalRow, priceClose: number, backtest: boolean): Promise<void>;
+}
+
 /**
  * Signal generation interval for throttling.
  * Enforces minimum time between getSignal calls.
@@ -1354,6 +1173,8 @@ interface IStrategyCallbacks {
     onPartialProfit: (symbol: string, data: IPublicSignalRow, currentPrice: number, revenuePercent: number, backtest: boolean) => void | Promise<void>;
     /** Called when signal is in partial loss state (price moved against position but not hit SL yet) */
     onPartialLoss: (symbol: string, data: IPublicSignalRow, currentPrice: number, lossPercent: number, backtest: boolean) => void | Promise<void>;
+    /** Called when signal reaches breakeven (stop-loss moved to entry price to protect capital) */
+    onBreakeven: (symbol: string, data: IPublicSignalRow, currentPrice: number, backtest: boolean) => void | Promise<void>;
     /** Called every minute regardless of strategy interval (for custom monitoring like checking if signal should be cancelled) */
     onPing: (symbol: string, data: IPublicSignalRow, when: Date, backtest: boolean) => void | Promise<void>;
 }
@@ -1592,17 +1413,53 @@ interface IStrategy {
      */
     getScheduledSignal: (symbol: string) => Promise<IPublicSignalRow | null>;
     /**
-     * Checks if the strategy has been stopped.
+     * Checks if breakeven threshold has been reached for the current pending signal.
      *
-     * Returns the stopped state indicating whether the strategy should
-     * cease processing new ticks or signals.
+     * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+     * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+     * Threshold: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2 transactions
      *
-     * @param symbol - Trading pair symbol
-     * @returns Promise resolving to true if strategy is stopped, false otherwise
-     */
-    getStopped: (symbol: string) => Promise<boolean>;
-    /**
-     * Fast backtest using historical candles.
+     * For LONG position:
+     * - Returns true when: currentPrice >= priceOpen * (1 + threshold%)
+     * - Example: entry=100, threshold=0.4% → true when price >= 100.4
+     *
+     * For SHORT position:
+     * - Returns true when: currentPrice <= priceOpen * (1 - threshold%)
+     * - Example: entry=100, threshold=0.4% → true when price <= 99.6
+     *
+     * Special cases:
+     * - Returns false if no pending signal exists
+     * - Returns true if trailing stop is already in profit zone (breakeven already achieved)
+     * - Returns false if threshold not reached yet
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price to check against threshold
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+     * const canBreakeven = await strategy.getBreakeven("BTCUSDT", 100.5);
+     * // Returns true (price >= 100.4)
+     *
+     * if (canBreakeven) {
+     *   await strategy.breakeven("BTCUSDT", 100.5, false);
+     * }
+     * ```
+     */
+    getBreakeven: (symbol: string, currentPrice: number) => Promise<boolean>;
+    /**
+     * Checks if the strategy has been stopped.
+     *
+     * Returns the stopped state indicating whether the strategy should
+     * cease processing new ticks or signals.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to true if strategy is stopped, false otherwise
+     */
+    getStopped: (symbol: string) => Promise<boolean>;
+    /**
+     * Fast backtest using historical candles.
      * Iterates through candles, calculates VWAP, checks TP/SL on each candle.
      *
      * For scheduled signals: first monitors activation/cancellation,
@@ -1770,13 +1627,441 @@ interface IStrategy {
      * }
      * ```
      */
-    trailingStop: (symbol: string, percentShift: number, backtest: boolean) => Promise<void>;
+    trailingStop: (symbol: string, percentShift: number, currentPrice: number, backtest: boolean) => Promise<void>;
+    /**
+     * Moves stop-loss to breakeven (entry price) when price reaches threshold.
+     *
+     * Moves SL to entry price (zero-risk position) when current price has moved
+     * far enough in profit direction to cover transaction costs (slippage + fees).
+     * Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+     *
+     * Behavior:
+     * - Returns true if SL was moved to breakeven
+     * - Returns false if conditions not met (threshold not reached or already at breakeven)
+     * - Uses _trailingPriceStopLoss to store breakeven SL (preserves original priceStopLoss)
+     * - Only moves SL once per position (idempotent - safe to call multiple times)
+     *
+     * For LONG position (entry=100, slippage=0.1%, fee=0.1%):
+     * - Threshold: (0.1 + 0.1) * 2 = 0.4%
+     * - Breakeven available when price >= 100.4 (entry + 0.4%)
+     * - Moves SL from original (e.g. 95) to 100 (breakeven)
+     * - Returns true on first successful move, false on subsequent calls
+     *
+     * For SHORT position (entry=100, slippage=0.1%, fee=0.1%):
+     * - Threshold: (0.1 + 0.1) * 2 = 0.4%
+     * - Breakeven available when price <= 99.6 (entry - 0.4%)
+     * - Moves SL from original (e.g. 105) to 100 (breakeven)
+     * - Returns true on first successful move, false on subsequent calls
+     *
+     * Validations:
+     * - Throws if no pending signal exists
+     * - Throws if currentPrice is not a positive finite number
+     *
+     * Use case: User-controlled breakeven protection triggered from onPartialProfit callback.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price to check threshold
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise<boolean> - true if breakeven was set, false if conditions not met
+     *
+     * @example
+     * ```typescript
+     * callbacks: {
+     *   onPartialProfit: async (symbol, signal, currentPrice, percentTp, backtest) => {
+     *     // Try to move SL to breakeven when threshold reached
+     *     const movedToBreakeven = await strategy.breakeven(symbol, currentPrice, backtest);
+     *     if (movedToBreakeven) {
+     *       console.log(`Position moved to breakeven at ${currentPrice}`);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    breakeven: (symbol: string, currentPrice: number, backtest: boolean) => Promise<boolean>;
 }
 /**
  * Unique strategy identifier.
  */
 type StrategyName = string;
 
+/**
+ * Unified breakeven event data for report generation.
+ * Contains all information about when signals reached breakeven.
+ */
+interface BreakevenEvent {
+    /** Event timestamp in milliseconds */
+    timestamp: number;
+    /** Trading pair symbol */
+    symbol: string;
+    /** Strategy name */
+    strategyName: StrategyName;
+    /** Signal ID */
+    signalId: string;
+    /** Position type */
+    position: string;
+    /** Current market price when breakeven was reached */
+    currentPrice: number;
+    /** Entry price (breakeven level) */
+    priceOpen: number;
+    /** True if backtest mode, false if live mode */
+    backtest: boolean;
+}
+/**
+ * Statistical data calculated from breakeven events.
+ *
+ * Provides metrics for breakeven milestone tracking.
+ *
+ * @example
+ * ```typescript
+ * const stats = await Breakeven.getData("BTCUSDT", "my-strategy");
+ *
+ * console.log(`Total breakeven events: ${stats.totalEvents}`);
+ * console.log(`Average threshold: ${stats.averageThreshold}%`);
+ * ```
+ */
+interface BreakevenStatisticsModel {
+    /** Array of all breakeven events with full details */
+    eventList: BreakevenEvent[];
+    /** Total number of breakeven events */
+    totalEvents: number;
+}
+
+declare const GLOBAL_CONFIG: {
+    /**
+     * Time to wait for scheduled signal to activate (in minutes)
+     * If signal does not activate within this time, it will be cancelled.
+     */
+    CC_SCHEDULE_AWAIT_MINUTES: number;
+    /**
+     * Number of candles to use for average price calculation (VWAP)
+     * Default: 5 candles (last 5 minutes when using 1m interval)
+     */
+    CC_AVG_PRICE_CANDLES_COUNT: number;
+    /**
+     * Slippage percentage applied to entry and exit prices.
+     * Simulates market impact and order book depth.
+     * Applied twice (entry and exit) for realistic execution simulation.
+     * Default: 0.1% per transaction
+     */
+    CC_PERCENT_SLIPPAGE: number;
+    /**
+     * Fee percentage charged per transaction.
+     * Applied twice (entry and exit) for total fee calculation.
+     * Default: 0.1% per transaction (total 0.2%)
+     */
+    CC_PERCENT_FEE: number;
+    /**
+     * Minimum TakeProfit distance from priceOpen (percentage)
+     * Must be greater than (slippage + fees) to ensure profitable trades
+     *
+     * Calculation:
+     * - Slippage effect: ~0.2% (0.1% × 2 transactions)
+     * - Fees: 0.2% (0.1% × 2 transactions)
+     * - Minimum profit buffer: 0.1%
+     * - Total: 0.5%
+     *
+     * Default: 0.5% (covers all costs + minimum profit margin)
+     */
+    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: number;
+    /**
+     * Minimum StopLoss distance from priceOpen (percentage)
+     * Prevents signals from being immediately stopped out due to price volatility
+     * Default: 0.5% (buffer to avoid instant stop loss on normal market fluctuations)
+     */
+    CC_MIN_STOPLOSS_DISTANCE_PERCENT: number;
+    /**
+     * Maximum StopLoss distance from priceOpen (percentage)
+     * Prevents catastrophic losses from extreme StopLoss values
+     * Default: 20% (one signal cannot lose more than 20% of position)
+     */
+    CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
+    /**
+     * Maximum signal lifetime in minutes
+     * Prevents eternal signals that block risk limits for weeks/months
+     * Default: 1440 minutes (1 day)
+     */
+    CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
+    /**
+     * Maximum time allowed for signal generation (in seconds).
+     * Prevents long-running or stuck signal generation routines from blocking
+     * execution or consuming resources indefinitely. If generation exceeds this
+     * threshold the attempt should be aborted, logged and optionally retried.
+     *
+     * Default: 180 seconds (3 minutes)
+     */
+    CC_MAX_SIGNAL_GENERATION_SECONDS: number;
+    /**
+     * Number of retries for getCandles function
+     * Default: 3 retries
+     */
+    CC_GET_CANDLES_RETRY_COUNT: number;
+    /**
+     * Delay between retries for getCandles function (in milliseconds)
+     * Default: 5000 ms (5 seconds)
+     */
+    CC_GET_CANDLES_RETRY_DELAY_MS: number;
+    /**
+     * Maximum allowed deviation factor for price anomaly detection.
+     * Price should not be more than this factor lower than reference price.
+     *
+     * Reasoning:
+     * - Incomplete candles from Binance API typically have prices near 0 (e.g., $0.01-1)
+     * - Normal BTC price ranges: $20,000-100,000
+     * - Factor 1000 catches prices below $20-100 when median is $20,000-100,000
+     * - Factor 100 would be too permissive (allows $200 when median is $20,000)
+     * - Factor 10000 might be too strict for low-cap altcoins
+     *
+     * Example: BTC at $50,000 median → threshold $50 (catches $0.01-1 anomalies)
+     */
+    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: number;
+    /**
+     * Minimum number of candles required for reliable median calculation.
+     * Below this threshold, use simple average instead of median.
+     *
+     * Reasoning:
+     * - Each candle provides 4 price points (OHLC)
+     * - 5 candles = 20 price points, sufficient for robust median calculation
+     * - Below 5 candles, single anomaly can heavily skew median
+     * - Statistical rule of thumb: minimum 7-10 data points for median stability
+     * - Average is more stable than median for small datasets (n < 20)
+     *
+     * Example: 3 candles = 12 points (use average), 5 candles = 20 points (use median)
+     */
+    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: number;
+    /**
+     * Controls visibility of signal notes in markdown report tables.
+     * When enabled, the "Note" column will be displayed in all markdown reports
+     * (backtest, live, schedule, risk, etc.)
+     *
+     * Default: false (notes are hidden to reduce table width and improve readability)
+     */
+    CC_REPORT_SHOW_SIGNAL_NOTE: boolean;
+    /**
+     * Breakeven threshold percentage - minimum profit distance from entry to enable breakeven.
+     * When price moves this percentage in profit direction, stop-loss can be moved to entry (breakeven).
+     *
+     * Calculation:
+     * - Slippage effect: ~0.2% (0.1% × 2 transactions)
+     * - Fees: 0.2% (0.1% × 2 transactions)
+     * - Total: 0.4%
+     * - Added buffer: 0.2%
+     * - Overall: 0.6%
+     *
+     * Default: 0.2% (additional buffer above costs to ensure no loss when moving to breakeven)
+     */
+    CC_BREAKEVEN_THRESHOLD: number;
+};
+/**
+ * Type for global configuration object.
+ */
+type GlobalConfig = typeof GLOBAL_CONFIG;
+
+/**
+ * Mapping of available table/markdown reports to their column definitions.
+ *
+ * Each property references a column definition object imported from
+ * `src/assets/*.columns`. These are used by markdown/report generators
+ * (backtest, live, schedule, risk, heat, performance, partial, walker).
+ */
+declare const COLUMN_CONFIG: {
+    /** Columns used in backtest markdown tables and reports */
+    backtest_columns: ColumnModel<IStrategyTickResultClosed>[];
+    /** Columns used by heatmap / heat reports */
+    heat_columns: ColumnModel<IHeatmapRow>[];
+    /** Columns for live trading reports and logs */
+    live_columns: ColumnModel<TickEvent>[];
+    /** Columns for partial-results / incremental reports */
+    partial_columns: ColumnModel<PartialEvent>[];
+    /** Columns for breakeven protection events */
+    breakeven_columns: ColumnModel<BreakevenEvent>[];
+    /** Columns for performance summary reports */
+    performance_columns: ColumnModel<MetricStats>[];
+    /** Columns for risk-related reports */
+    risk_columns: ColumnModel<RiskEvent>[];
+    /** Columns for scheduled report output */
+    schedule_columns: ColumnModel<ScheduledEvent>[];
+    /** Walker: PnL summary columns */
+    walker_pnl_columns: ColumnModel<SignalData$1>[];
+    /** Walker: strategy-level summary columns */
+    walker_strategy_columns: ColumnModel<IStrategyResult>[];
+};
+/**
+ * Type for the column configuration object.
+ */
+type ColumnConfig = typeof COLUMN_CONFIG;
+
+/**
+ * Sets custom logger implementation for the framework.
+ *
+ * All log messages from internal services will be forwarded to the provided logger
+ * with automatic context injection (strategyName, exchangeName, symbol, etc.).
+ *
+ * @param logger - Custom logger implementing ILogger interface
+ *
+ * @example
+ * ```typescript
+ * setLogger({
+ *   log: (topic, ...args) => console.log(topic, args),
+ *   debug: (topic, ...args) => console.debug(topic, args),
+ *   info: (topic, ...args) => console.info(topic, args),
+ * });
+ * ```
+ */
+declare function setLogger(logger: ILogger): void;
+/**
+ * Sets global configuration parameters for the framework.
+ * @param config - Partial configuration object to override default settings
+ * @param _unsafe - Skip config validations - required for testbed
+ *
+ * @example
+ * ```typescript
+ * setConfig({
+ *   CC_SCHEDULE_AWAIT_MINUTES: 90,
+ * });
+ * ```
+ */
+declare function setConfig(config: Partial<GlobalConfig>, _unsafe?: boolean): void;
+/**
+ * Retrieves a copy of the current global configuration.
+ *
+ * Returns a shallow copy of the current GLOBAL_CONFIG to prevent accidental mutations.
+ * Use this to inspect the current configuration state without modifying it.
+ *
+ * @returns {GlobalConfig} A copy of the current global configuration object
+ *
+ * @example
+ * ```typescript
+ * const currentConfig = getConfig();
+ * console.log(currentConfig.CC_SCHEDULE_AWAIT_MINUTES);
+ * ```
+ */
+declare function getConfig(): {
+    CC_SCHEDULE_AWAIT_MINUTES: number;
+    CC_AVG_PRICE_CANDLES_COUNT: number;
+    CC_PERCENT_SLIPPAGE: number;
+    CC_PERCENT_FEE: number;
+    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: number;
+    CC_MIN_STOPLOSS_DISTANCE_PERCENT: number;
+    CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
+    CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
+    CC_MAX_SIGNAL_GENERATION_SECONDS: number;
+    CC_GET_CANDLES_RETRY_COUNT: number;
+    CC_GET_CANDLES_RETRY_DELAY_MS: number;
+    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: number;
+    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: number;
+    CC_REPORT_SHOW_SIGNAL_NOTE: boolean;
+    CC_BREAKEVEN_THRESHOLD: number;
+};
+/**
+ * Retrieves the default configuration object for the framework.
+ *
+ * Returns a reference to the default configuration with all preset values.
+ * Use this to see what configuration options are available and their default values.
+ *
+ * @returns {GlobalConfig} The default configuration object
+ *
+ * @example
+ * ```typescript
+ * const defaultConfig = getDefaultConfig();
+ * console.log(defaultConfig.CC_SCHEDULE_AWAIT_MINUTES);
+ * ```
+ */
+declare function getDefaultConfig(): Readonly<{
+    CC_SCHEDULE_AWAIT_MINUTES: number;
+    CC_AVG_PRICE_CANDLES_COUNT: number;
+    CC_PERCENT_SLIPPAGE: number;
+    CC_PERCENT_FEE: number;
+    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: number;
+    CC_MIN_STOPLOSS_DISTANCE_PERCENT: number;
+    CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
+    CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
+    CC_MAX_SIGNAL_GENERATION_SECONDS: number;
+    CC_GET_CANDLES_RETRY_COUNT: number;
+    CC_GET_CANDLES_RETRY_DELAY_MS: number;
+    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: number;
+    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: number;
+    CC_REPORT_SHOW_SIGNAL_NOTE: boolean;
+    CC_BREAKEVEN_THRESHOLD: number;
+}>;
+/**
+ * Sets custom column configurations for markdown report generation.
+ *
+ * Allows overriding default column definitions for any report type.
+ * All columns are validated before assignment to ensure structural correctness.
+ *
+ * @param columns - Partial column configuration object to override default column settings
+ * @param _unsafe - Skip column validations - required for testbed
+ *
+ * @example
+ * ```typescript
+ * setColumns({
+ *   backtest_columns: [
+ *     {
+ *       key: "customId",
+ *       label: "Custom ID",
+ *       format: (data) => data.signal.id,
+ *       isVisible: () => true
+ *     }
+ *   ],
+ * });
+ * ```
+ *
+ * @throws {Error} If column configuration is invalid
+ */
+declare function setColumns(columns: Partial<ColumnConfig>, _unsafe?: boolean): void;
+/**
+ * Retrieves a copy of the current column configuration for markdown report generation.
+ *
+ * Returns a shallow copy of the current COLUMN_CONFIG to prevent accidental mutations.
+ * Use this to inspect the current column definitions without modifying them.
+ *
+ * @returns {ColumnConfig} A copy of the current column configuration object
+ *
+ * @example
+ * ```typescript
+ * const currentColumns = getColumns();
+ * console.log(currentColumns.backtest_columns.length);
+ * ```
+ */
+declare function getColumns(): {
+    backtest_columns: ColumnModel<IStrategyTickResultClosed>[];
+    heat_columns: ColumnModel<IHeatmapRow>[];
+    live_columns: ColumnModel<TickEvent>[];
+    partial_columns: ColumnModel<PartialEvent>[];
+    breakeven_columns: ColumnModel<BreakevenEvent>[];
+    performance_columns: ColumnModel<MetricStats>[];
+    risk_columns: ColumnModel<RiskEvent>[];
+    schedule_columns: ColumnModel<ScheduledEvent>[];
+    walker_pnl_columns: ColumnModel<SignalData$1>[];
+    walker_strategy_columns: ColumnModel<IStrategyResult>[];
+};
+/**
+ * Retrieves the default column configuration object for markdown report generation.
+ *
+ * Returns a reference to the default column definitions with all preset values.
+ * Use this to see what column options are available and their default definitions.
+ *
+ * @returns {ColumnConfig} The default column configuration object
+ *
+ * @example
+ * ```typescript
+ * const defaultColumns = getDefaultColumns();
+ * console.log(defaultColumns.backtest_columns);
+ * ```
+ */
+declare function getDefaultColumns(): Readonly<{
+    backtest_columns: ColumnModel<IStrategyTickResultClosed>[];
+    heat_columns: ColumnModel<IHeatmapRow>[];
+    live_columns: ColumnModel<TickEvent>[];
+    partial_columns: ColumnModel<PartialEvent>[];
+    breakeven_columns: ColumnModel<BreakevenEvent>[];
+    performance_columns: ColumnModel<MetricStats>[];
+    risk_columns: ColumnModel<RiskEvent>[];
+    schedule_columns: ColumnModel<ScheduledEvent>[];
+    walker_pnl_columns: ColumnModel<SignalData$1>[];
+    walker_strategy_columns: ColumnModel<IStrategyResult>[];
+}>;
+
 /**
  * Statistical data calculated from backtest results.
  *
@@ -3515,6 +3800,91 @@ interface PartialLossContract {
     timestamp: number;
 }
 
+/**
+ * Contract for breakeven events.
+ *
+ * Emitted by breakevenSubject when a signal's stop-loss is moved to breakeven (entry price).
+ * Used for tracking risk reduction milestones and monitoring strategy safety.
+ *
+ * Events are emitted only once per signal (idempotent - protected by ClientBreakeven state).
+ * Breakeven is triggered when price moves far enough in profit direction to cover transaction costs.
+ *
+ * Consumers:
+ * - BreakevenMarkdownService: Accumulates events for report generation
+ * - User callbacks via listenBreakeven() / listenBreakevenOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenBreakeven } from "backtest-kit";
+ *
+ * // Listen to all breakeven events
+ * listenBreakeven((event) => {
+ *   console.log(`[${event.backtest ? "Backtest" : "Live"}] Signal ${event.data.id} moved to breakeven`);
+ *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
+ *   console.log(`Position: ${event.data.position}, Entry: ${event.data.priceOpen}`);
+ *   console.log(`Original SL: ${event.data.priceStopLoss}, New SL: ${event.data.priceOpen}`);
+ * });
+ *
+ * // Wait for specific signal to reach breakeven
+ * listenBreakevenOnce(
+ *   (event) => event.data.id === "target-signal-id",
+ *   (event) => console.log("Signal reached breakeven:", event.data.id)
+ * );
+ * ```
+ */
+interface BreakevenContract {
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this breakeven event belongs to.
+     */
+    symbol: string;
+    /**
+     * Strategy name that generated this signal.
+     * Identifies which strategy execution this breakeven event belongs to.
+     */
+    strategyName: StrategyName;
+    /**
+     * Exchange name where this signal is being executed.
+     * Identifies which exchange this breakeven event belongs to.
+     */
+    exchangeName: ExchangeName;
+    /**
+     * Frame name where this signal is being executed.
+     * Identifies which frame this breakeven event belongs to (empty string for live mode).
+     */
+    frameName: FrameName;
+    /**
+     * Complete signal row data.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
+     */
+    data: ISignalRow;
+    /**
+     * Current market price at which breakeven was triggered.
+     * Used to verify threshold calculation.
+     */
+    currentPrice: number;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment breakeven was set
+     * - Backtest mode: candle.timestamp of the candle that triggered breakeven
+     *
+     * @example
+     * ```typescript
+     * const eventDate = new Date(event.timestamp);
+     * console.log(`Breakeven set at: ${eventDate.toISOString()}`);
+     * ```
+     */
+    timestamp: number;
+}
+
 /**
  * Contract for risk rejection events.
  *
@@ -4414,6 +4784,64 @@ declare function listenPartialLoss(fn: (event: PartialLossContract) => void): ()
  * ```
  */
 declare function listenPartialLossOnce(filterFn: (event: PartialLossContract) => boolean, fn: (event: PartialLossContract) => void): () => void;
+/**
+ * Subscribes to breakeven protection events with queued async processing.
+ *
+ * Emits when a signal's stop-loss is moved to breakeven (entry price).
+ * This happens when price moves far enough in profit direction to cover transaction costs.
+ * 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 breakeven events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenBreakeven } from "./function/event";
+ *
+ * const unsubscribe = listenBreakeven((event) => {
+ *   console.log(`Signal ${event.data.id} reached breakeven`);
+ *   console.log(`Symbol: ${event.symbol}, Position: ${event.data.position}`);
+ *   console.log(`Entry: ${event.data.priceOpen}, Current: ${event.currentPrice}`);
+ *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenBreakeven(fn: (event: BreakevenContract) => void): () => void;
+/**
+ * Subscribes to filtered breakeven protection events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific breakeven conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenBreakevenOnce } from "./function/event";
+ *
+ * // Wait for first breakeven on any signal
+ * listenBreakevenOnce(
+ *   (event) => true,
+ *   (event) => console.log("First breakeven reached:", event.data.id)
+ * );
+ *
+ * // Wait for breakeven on BTCUSDT LONG position
+ * const cancel = listenBreakevenOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.data.position === "long",
+ *   (event) => console.log("BTCUSDT LONG reached breakeven at", event.currentPrice)
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+declare function listenBreakevenOnce(filterFn: (event: BreakevenContract) => boolean, fn: (event: BreakevenContract) => void): () => void;
 /**
  * Subscribes to risk rejection events with queued async processing.
  *
@@ -5481,6 +5909,12 @@ interface IPersistBase<Entity extends IEntity | null = IEntity> {
      * @throws Error if write fails
      */
     writeValue(entityId: EntityId, entity: Entity): Promise<void>;
+    /**
+     * Async generator yielding all entity IDs.
+     *
+     * @returns AsyncGenerator yielding entity IDs
+     */
+    keys(): AsyncGenerator<EntityId>;
 }
 /**
  * Base class for file-based persistence with atomic writes.
@@ -5615,9 +6049,10 @@ declare class PersistSignalUtils {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise resolving to signal or null
      */
-    readSignalData: (symbol: string, strategyName: StrategyName) => Promise<ISignalRow | null>;
+    readSignalData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName) => Promise<ISignalRow | null>;
     /**
      * Writes signal data to disk with atomic file writes.
      *
@@ -5627,9 +6062,10 @@ declare class PersistSignalUtils {
      * @param signalRow - Signal data (null to clear)
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise that resolves when write is complete
      */
-    writeSignalData: (signalRow: ISignalRow | null, symbol: string, strategyName: StrategyName) => Promise<void>;
+    writeSignalData: (signalRow: ISignalRow | null, symbol: string, strategyName: StrategyName, exchangeName: ExchangeName) => Promise<void>;
 }
 /**
  * Global singleton instance of PersistSignalUtils.
@@ -5689,9 +6125,10 @@ declare class PersistRiskUtils {
      * Returns empty Map if no positions exist.
      *
      * @param riskName - Risk profile identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise resolving to Map of active positions
      */
-    readPositionData: (riskName: RiskName) => Promise<RiskData>;
+    readPositionData: (riskName: RiskName, exchangeName: ExchangeName) => Promise<RiskData>;
     /**
      * Writes active positions to disk with atomic file writes.
      *
@@ -5700,9 +6137,10 @@ declare class PersistRiskUtils {
      *
      * @param positions - Map of active positions
      * @param riskName - Risk profile identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise that resolves when write is complete
      */
-    writePositionData: (riskRow: RiskData, riskName: RiskName) => Promise<void>;
+    writePositionData: (riskRow: RiskData, riskName: RiskName, exchangeName: ExchangeName) => Promise<void>;
 }
 /**
  * Global singleton instance of PersistRiskUtils.
@@ -5763,9 +6201,10 @@ declare class PersistScheduleUtils {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise resolving to scheduled signal or null
      */
-    readScheduleData: (symbol: string, strategyName: StrategyName) => Promise<IScheduledSignalRow | null>;
+    readScheduleData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName) => Promise<IScheduledSignalRow | null>;
     /**
      * Writes scheduled signal data to disk with atomic file writes.
      *
@@ -5775,9 +6214,10 @@ declare class PersistScheduleUtils {
      * @param scheduledSignalRow - Scheduled signal data (null to clear)
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise that resolves when write is complete
      */
-    writeScheduleData: (scheduledSignalRow: IScheduledSignalRow | null, symbol: string, strategyName: StrategyName) => Promise<void>;
+    writeScheduleData: (scheduledSignalRow: IScheduledSignalRow | null, symbol: string, strategyName: StrategyName, exchangeName: ExchangeName) => Promise<void>;
 }
 /**
  * Global singleton instance of PersistScheduleUtils.
@@ -5838,9 +6278,11 @@ declare class PersistPartialUtils {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy identifier
+     * @param signalId - Signal identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise resolving to partial data record
      */
-    readPartialData: (symbol: string, strategyName: StrategyName) => Promise<PartialData>;
+    readPartialData: (symbol: string, strategyName: StrategyName, signalId: string, exchangeName: ExchangeName) => Promise<PartialData>;
     /**
      * Writes partial data to disk with atomic file writes.
      *
@@ -5850,9 +6292,11 @@ declare class PersistPartialUtils {
      * @param partialData - Record of signal IDs to partial data
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy identifier
+     * @param signalId - Signal identifier
+     * @param exchangeName - Exchange identifier
      * @returns Promise that resolves when write is complete
      */
-    writePartialData: (partialData: PartialData, symbol: string, strategyName: StrategyName) => Promise<void>;
+    writePartialData: (partialData: PartialData, symbol: string, strategyName: StrategyName, signalId: string, exchangeName: ExchangeName) => Promise<void>;
 }
 /**
  * Global singleton instance of PersistPartialUtils.
@@ -5871,6 +6315,120 @@ declare class PersistPartialUtils {
  * ```
  */
 declare const PersistPartialAdapter: PersistPartialUtils;
+/**
+ * Type for persisted breakeven data.
+ * Stores breakeven state (reached flag) for each signal ID.
+ */
+type BreakevenData = Record<string, IBreakevenData>;
+/**
+ * Persistence utility class for breakeven state management.
+ *
+ * Handles reading and writing breakeven state to disk.
+ * Uses memoized PersistBase instances per symbol-strategy pair.
+ *
+ * Features:
+ * - Atomic file writes via PersistBase.writeValue()
+ * - Lazy initialization on first access
+ * - Singleton pattern for global access
+ * - Custom adapter support via usePersistBreakevenAdapter()
+ *
+ * File structure:
+ * ```
+ * ./dump/data/breakeven/
+ * ├── BTCUSDT_my-strategy/
+ * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
+ * └── ETHUSDT_other-strategy/
+ *     └── state.json
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ * // Returns: { "signal-id": { reached: true }, ... }
+ *
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * ```
+ */
+declare class PersistBreakevenUtils {
+    /**
+     * Factory for creating PersistBase instances.
+     * Can be replaced via usePersistBreakevenAdapter().
+     */
+    private PersistBreakevenFactory;
+    /**
+     * Memoized storage factory for breakeven data.
+     * Creates one PersistBase instance per symbol-strategy-exchange combination.
+     * Key format: "symbol:strategyName:exchangeName"
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @returns PersistBase instance for this symbol-strategy-exchange combination
+     */
+    private getBreakevenStorage;
+    /**
+     * 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)); }
+     * }
+     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
+     * ```
+     */
+    usePersistBreakevenAdapter(Ctor: TPersistBaseCtor<string, BreakevenData>): void;
+    /**
+     * Reads persisted breakeven data for a symbol and strategy.
+     *
+     * Called by ClientBreakeven.waitForInit() to restore state.
+     * Returns empty object if no breakeven data exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param signalId - Signal identifier
+     * @param exchangeName - Exchange identifier
+     * @returns Promise resolving to breakeven data record
+     */
+    readBreakevenData: (symbol: string, strategyName: StrategyName, signalId: string, exchangeName: ExchangeName) => Promise<BreakevenData>;
+    /**
+     * Writes breakeven data to disk.
+     *
+     * Called by ClientBreakeven._persistState() after state changes.
+     * Creates directory and file if they don't exist.
+     * Uses atomic writes to prevent data corruption.
+     *
+     * @param breakevenData - Breakeven data record to persist
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param signalId - Signal identifier
+     * @param exchangeName - Exchange identifier
+     * @returns Promise that resolves when write is complete
+     */
+    writeBreakevenData: (breakevenData: BreakevenData, symbol: string, strategyName: StrategyName, signalId: string, exchangeName: ExchangeName) => Promise<void>;
+}
+/**
+ * Global singleton instance of PersistBreakevenUtils.
+ * Used by ClientBreakeven for breakeven state persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
+ *
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ *
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * ```
+ */
+declare const PersistBreakevenAdapter: PersistBreakevenUtils;
 
 /**
  * Type alias for column configuration used in backtest markdown reports.
@@ -5903,7 +6461,7 @@ declare const PersistPartialAdapter: PersistPartialUtils;
  * @see ColumnModel for the base interface
  * @see IStrategyTickResultClosed for the signal data structure
  */
-type Columns$6 = ColumnModel<IStrategyTickResultClosed>;
+type Columns$7 = ColumnModel<IStrategyTickResultClosed>;
 /**
  * Service for generating and saving backtest markdown reports.
  *
@@ -5997,7 +6555,7 @@ declare class BacktestMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -6022,7 +6580,7 @@ declare class BacktestMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", true, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Clears accumulated signal data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -6172,6 +6730,35 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<IScheduledSignalRow>;
+    /**
+     * Checks if breakeven threshold has been reached for the current pending signal.
+     *
+     * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+     * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check against threshold
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const canBreakeven = await Backtest.getBreakeven("BTCUSDT", 100.5, {
+     *   strategyName: "my-strategy",
+     *   exchangeName: "binance",
+     *   frameName: "backtest_frame"
+     * });
+     * if (canBreakeven) {
+     *   console.log("Breakeven threshold reached");
+     *   await Backtest.breakeven("BTCUSDT", 100.5, context);
+     * }
+     * ```
+     */
+    getBreakeven: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -6297,25 +6884,52 @@ declare class BacktestUtils {
      *
      * @param symbol - Trading pair symbol
      * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
      * @param context - Execution context with strategyName, exchangeName, and frameName
      * @returns Promise that resolves when trailing SL is updated
      *
      * @example
      * ```typescript
-     * // LONG: entry=100, originalSL=90, distance=10
-     * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
-     * await Backtest.trailingStop("BTCUSDT", -50, {
+     * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+     * // Tighten stop by 50%: newSL = 100 - 5% = 95
+     * await Backtest.trailingStop("BTCUSDT", -50, 102, {
      *   exchangeName: "binance",
      *   frameName: "frame1",
      *   strategyName: "my-strategy"
      * });
      * ```
      */
-    trailingStop: (symbol: string, percentShift: number, context: {
+    trailingStop: (symbol: string, percentShift: number, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Moves stop-loss to breakeven when price reaches threshold.
+     *
+     * Moves SL to entry price (zero-risk position) when current price has moved
+     * far enough in profit direction. Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check threshold
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven was set, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const moved = await Backtest.breakeven(
+     *   "BTCUSDT",
+     *   112,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }
+     * );
+     * console.log(moved); // true (SL moved to entry price)
+     * ```
+     */
+    breakeven: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Gets statistical data from all closed signals for a symbol-strategy pair.
      *
@@ -6362,7 +6976,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, columns?: Columns$6[]) => Promise<string>;
+    }, columns?: Columns$7[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -6393,7 +7007,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, path?: string, columns?: Columns$6[]) => Promise<void>;
+    }, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Lists all active backtest instances with their current status.
      *
@@ -6467,7 +7081,7 @@ declare const Backtest: BacktestUtils;
  * @see ColumnModel for the base interface
  * @see TickEvent for the event data structure
  */
-type Columns$5 = ColumnModel<TickEvent>;
+type Columns$6 = ColumnModel<TickEvent>;
 /**
  * Service for generating and saving live trading markdown reports.
  *
@@ -6566,7 +7180,7 @@ declare class LiveMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -6591,7 +7205,7 @@ declare class LiveMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -6750,6 +7364,33 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<IScheduledSignalRow>;
+    /**
+     * Checks if breakeven threshold has been reached for the current pending signal.
+     *
+     * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+     * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check against threshold
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const canBreakeven = await Live.getBreakeven("BTCUSDT", 100.5, {
+     *   strategyName: "my-strategy",
+     *   exchangeName: "binance"
+     * });
+     * if (canBreakeven) {
+     *   console.log("Breakeven threshold reached");
+     *   await Live.breakeven("BTCUSDT", 100.5, context);
+     * }
+     * ```
+     */
+    getBreakeven: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -6864,23 +7505,49 @@ declare class LiveUtils {
      *
      * @param symbol - Trading pair symbol
      * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
      * @param context - Execution context with strategyName and exchangeName
      * @returns Promise that resolves when trailing SL is updated
      *
      * @example
      * ```typescript
-     * // LONG: entry=100, originalSL=90, distance=10
-     * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
-     * await Live.trailingStop("BTCUSDT", -50, {
+     * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+     * // Tighten stop by 50%: newSL = 100 - 5% = 95
+     * await Live.trailingStop("BTCUSDT", -50, 102, {
      *   exchangeName: "binance",
      *   strategyName: "my-strategy"
      * });
      * ```
      */
-    trailingStop: (symbol: string, percentShift: number, context: {
+    trailingStop: (symbol: string, percentShift: number, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<void>;
+    /**
+     * Moves stop-loss to breakeven when price reaches threshold.
+     *
+     * Moves SL to entry price (zero-risk position) when current price has moved
+     * far enough in profit direction. Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check threshold
+     * @param context - Strategy context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if breakeven was set, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const moved = await Live.breakeven(
+     *   "BTCUSDT",
+     *   112,
+     *   { strategyName: "my-strategy", exchangeName: "binance" }
+     * );
+     * console.log(moved); // true (SL moved to entry price)
+     * ```
+     */
+    breakeven: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
     /**
      * Gets statistical data from all live trading events for a symbol-strategy pair.
      *
@@ -6925,7 +7592,7 @@ declare class LiveUtils {
     getReport: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, columns?: Columns$5[]) => Promise<string>;
+    }, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -6955,7 +7622,7 @@ declare class LiveUtils {
     dump: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, path?: string, columns?: Columns$5[]) => Promise<void>;
+    }, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
      * Lists all active live trading instances with their current status.
      *
@@ -7025,7 +7692,7 @@ declare const Live: LiveUtils;
  * @see ColumnModel for the base interface
  * @see ScheduledEvent for the event data structure
  */
-type Columns$4 = ColumnModel<ScheduledEvent>;
+type Columns$5 = ColumnModel<ScheduledEvent>;
 /**
  * Service for generating and saving scheduled signals markdown reports.
  *
@@ -7108,7 +7775,7 @@ declare class ScheduleMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -7133,7 +7800,7 @@ declare class ScheduleMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -7240,7 +7907,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$4[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -7262,7 +7929,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
 }
 /**
  * Singleton instance of ScheduleUtils for convenient scheduled signals reporting.
@@ -7308,7 +7975,7 @@ declare const Schedule: ScheduleUtils;
  * @see ColumnModel for the base interface
  * @see MetricStats for the metric data structure
  */
-type Columns$3 = ColumnModel<MetricStats>;
+type Columns$4 = ColumnModel<MetricStats>;
 /**
  * Service for collecting and analyzing performance metrics.
  *
@@ -7387,7 +8054,7 @@ declare class PerformanceMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$3[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -7408,7 +8075,7 @@ declare class PerformanceMarkdownService {
      * await performanceService.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$3[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
     /**
      * Clears accumulated performance data from storage.
      *
@@ -7526,7 +8193,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$3[]): Promise<string>;
+    }, backtest?: boolean, columns?: Columns$4[]): Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -7551,7 +8218,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$3[]): Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$4[]): Promise<void>;
 }
 
 /**
@@ -7971,7 +8638,7 @@ declare const Walker: WalkerUtils;
  * @see ColumnModel for the base interface
  * @see IHeatmapRow for the row data structure
  */
-type Columns$2 = ColumnModel<IHeatmapRow>;
+type Columns$3 = ColumnModel<IHeatmapRow>;
 /**
  * Portfolio Heatmap Markdown Service.
  *
@@ -8064,7 +8731,7 @@ declare class HeatMarkdownService {
      * // ...
      * ```
      */
-    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$2[]) => Promise<string>;
+    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$3[]) => Promise<string>;
     /**
      * Saves heatmap report to disk.
      *
@@ -8089,7 +8756,7 @@ declare class HeatMarkdownService {
      * await service.dump("my-strategy", "binance", "frame1", true, "./reports");
      * ```
      */
-    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
+    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$3[]) => Promise<void>;
     /**
      * Clears accumulated heatmap data from storage.
      * If payload is provided, clears only that exchangeName+frameName+backtest combination's data.
@@ -8236,7 +8903,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$2[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$3[]) => Promise<string>;
     /**
      * Saves heatmap report to disk for a strategy.
      *
@@ -8269,7 +8936,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$3[]) => Promise<void>;
 }
 /**
  * Singleton instance of HeatUtils for convenient heatmap operations.
@@ -8500,7 +9167,7 @@ declare const Optimizer: OptimizerUtils;
  * @see ColumnModel for the base interface
  * @see PartialEvent for the event data structure
  */
-type Columns$1 = ColumnModel<PartialEvent>;
+type Columns$2 = ColumnModel<PartialEvent>;
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -8594,7 +9261,7 @@ declare class PartialMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$1[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$2[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -8619,7 +9286,7 @@ declare class PartialMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -8772,7 +9439,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$1[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$2[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -8809,7 +9476,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
 }
 /**
  * Global singleton instance of PartialUtils.
@@ -8937,7 +9604,7 @@ declare const Constant: ConstantUtils;
  * @see ColumnModel for the base interface
  * @see RiskEvent for the event data structure
  */
-type Columns = ColumnModel<RiskEvent>;
+type Columns$1 = ColumnModel<RiskEvent>;
 /**
  * Service for generating and saving risk rejection markdown reports.
  *
@@ -9018,7 +9685,7 @@ declare class RiskMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$1[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -9043,7 +9710,7 @@ declare class RiskMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -9198,7 +9865,7 @@ declare class RiskUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$1[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -9235,7 +9902,7 @@ declare class RiskUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
 }
 /**
  * Global singleton instance of RiskUtils.
@@ -9552,32 +10219,369 @@ declare class NotificationUtils {
      *
      * @example
      * ```typescript
-     * await Notification.clear();
+     * await Notification.clear();
+     * ```
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Singleton instance of NotificationUtils for convenient notification access.
+ *
+ * @example
+ * ```typescript
+ * import { Notification } from "./classes/Notification";
+ *
+ * // Get all notifications
+ * const all = await Notification.getData();
+ *
+ * // Filter by type using type discrimination
+ * const closedSignals = all.filter(n => n.type === "signal.closed");
+ * const highLosses = all.filter(n =>
+ *   n.type === "partial.loss" && n.level >= 30
+ * );
+ *
+ * // Clear history
+ * await Notification.clear();
+ * ```
+ */
+declare const Notification: NotificationUtils;
+
+/**
+ * Type alias for column configuration used in breakeven markdown reports.
+ *
+ * Represents a column model specifically designed to format and display
+ * breakeven events in markdown tables.
+ *
+ * @typeParam BreakevenEvent - The breakeven event data type containing
+ *   signal information, symbol, and timing details
+ *
+ * @example
+ * ```typescript
+ * // Column to display symbol
+ * const symbolColumn: Columns = {
+ *   key: "symbol",
+ *   label: "Symbol",
+ *   format: (event) => event.symbol,
+ *   isVisible: () => true
+ * };
+ *
+ * // Column to display price when breakeven was reached
+ * const priceColumn: Columns = {
+ *   key: "currentPrice",
+ *   label: "Price",
+ *   format: (event) => event.currentPrice.toString(),
+ *   isVisible: () => true
+ * };
+ * ```
+ *
+ * @see ColumnModel for the base interface
+ * @see BreakevenEvent for the event data structure
+ */
+type Columns = ColumnModel<BreakevenEvent>;
+/**
+ * Service for generating and saving breakeven markdown reports.
+ *
+ * Features:
+ * - Listens to breakeven events via breakevenSubject
+ * - Accumulates all events per symbol-strategy pair
+ * - Generates markdown tables with detailed event information
+ * - Provides statistics (total breakeven events)
+ * - Saves reports to disk in dump/breakeven/{symbol}_{strategyName}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new BreakevenMarkdownService();
+ *
+ * // Service automatically subscribes to subjects on init
+ * // No manual callback setup needed
+ *
+ * // Later: generate and save report
+ * await service.dump("BTCUSDT", "my-strategy");
+ * ```
+ */
+declare class BreakevenMarkdownService {
+    /** Logger service for debug output */
+    private readonly loggerService;
+    /**
+     * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
+     * Each combination gets its own isolated storage instance.
+     */
+    private getStorage;
+    /**
+     * Processes breakeven events and accumulates them.
+     * Should be called from breakevenSubject subscription.
+     *
+     * @param data - Breakeven event data with frameName wrapper
+     *
+     * @example
+     * ```typescript
+     * const service = new BreakevenMarkdownService();
+     * // Service automatically subscribes in init()
+     * ```
+     */
+    private tickBreakeven;
+    /**
+     * Gets statistical data from all breakeven events for a symbol-strategy pair.
+     * Delegates to ReportStorage.getData().
+     *
+     * @param symbol - Trading pair symbol to get data for
+     * @param strategyName - Strategy name to get data for
+     * @param exchangeName - Exchange name
+     * @param frameName - Frame name
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Statistical data object with all metrics
+     *
+     * @example
+     * ```typescript
+     * const service = new BreakevenMarkdownService();
+     * const stats = await service.getData("BTCUSDT", "my-strategy", "binance", "1h", false);
+     * console.log(stats.totalEvents);
+     * ```
+     */
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<BreakevenStatisticsModel>;
+    /**
+     * Generates markdown report with all breakeven events for a symbol-strategy pair.
+     * Delegates to ReportStorage.getReport().
+     *
+     * @param symbol - Trading pair symbol to generate report for
+     * @param strategyName - Strategy name to generate report for
+     * @param exchangeName - Exchange name
+     * @param frameName - Frame name
+     * @param backtest - True if backtest mode, false if live mode
+     * @param columns - Column configuration for formatting the table
+     * @returns Markdown formatted report string with table of all events
+     *
+     * @example
+     * ```typescript
+     * const service = new BreakevenMarkdownService();
+     * const markdown = await service.getReport("BTCUSDT", "my-strategy", "binance", "1h", false);
+     * console.log(markdown);
+     * ```
+     */
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns[]) => Promise<string>;
+    /**
+     * Saves symbol-strategy report to disk.
+     * Creates directory if it doesn't exist.
+     * Delegates to ReportStorage.dump().
+     *
+     * @param symbol - Trading pair symbol to save report for
+     * @param strategyName - Strategy name to save report for
+     * @param exchangeName - Exchange name
+     * @param frameName - Frame name
+     * @param backtest - True if backtest mode, false if live mode
+     * @param path - Directory path to save report (default: "./dump/breakeven")
+     * @param columns - Column configuration for formatting the table
+     *
+     * @example
+     * ```typescript
+     * const service = new BreakevenMarkdownService();
+     *
+     * // Save to default path: ./dump/breakeven/BTCUSDT_my-strategy.md
+     * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
+     *
+     * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
+     * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
+     * ```
+     */
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+    /**
+     * Clears accumulated event data from storage.
+     * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
+     * If nothing is provided, clears all data.
+     *
+     * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
+     *
+     * @example
+     * ```typescript
+     * const service = new BreakevenMarkdownService();
+     *
+     * // Clear specific combination
+     * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
+     *
+     * // Clear all data
+     * await service.clear();
+     * ```
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+        backtest: boolean;
+    }) => Promise<void>;
+    /**
+     * Initializes the service by subscribing to breakeven events.
+     * Uses singleshot to ensure initialization happens only once.
+     * Automatically called on first use.
+     *
+     * @example
+     * ```typescript
+     * const service = new BreakevenMarkdownService();
+     * await service.init(); // Subscribe to breakeven events
+     * ```
+     */
+    protected init: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    /**
+     * Function to unsubscribe from breakeven events.
+     * Assigned during init().
+     */
+    unsubscribe: Function;
+}
+
+/**
+ * Utility class for accessing breakeven protection reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by BreakevenMarkdownService from breakeven events.
+ *
+ * Features:
+ * - Statistical data extraction (total breakeven events count)
+ * - Markdown report generation with event tables
+ * - File export to disk
+ *
+ * Data source:
+ * - BreakevenMarkdownService listens to breakevenSubject
+ * - Accumulates events in ReportStorage (max 250 events per symbol-strategy pair)
+ * - Events include: timestamp, symbol, strategyName, signalId, position, priceOpen, currentPrice, mode
+ *
+ * @example
+ * ```typescript
+ * import { Breakeven } from "./classes/Breakeven";
+ *
+ * // Get statistical data for BTCUSDT:my-strategy
+ * const stats = await Breakeven.getData("BTCUSDT", "my-strategy");
+ * console.log(`Total breakeven events: ${stats.totalEvents}`);
+ *
+ * // Generate markdown report
+ * const markdown = await Breakeven.getReport("BTCUSDT", "my-strategy");
+ * console.log(markdown); // Formatted table with all events
+ *
+ * // Export report to file
+ * await Breakeven.dump("BTCUSDT", "my-strategy"); // Saves to ./dump/breakeven/BTCUSDT_my-strategy.md
+ * await Breakeven.dump("BTCUSDT", "my-strategy", "./custom/path"); // Custom directory
+ * ```
+ */
+declare class BreakevenUtils {
+    /**
+     * Retrieves statistical data from accumulated breakeven events.
+     *
+     * Delegates to BreakevenMarkdownService.getData() which reads from ReportStorage.
+     * Returns aggregated metrics calculated from all breakeven events.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name (e.g., "my-strategy")
+     * @returns Promise resolving to BreakevenStatisticsModel object with counts and event list
+     *
+     * @example
+     * ```typescript
+     * const stats = await Breakeven.getData("BTCUSDT", "my-strategy");
+     *
+     * console.log(`Total breakeven events: ${stats.totalEvents}`);
+     *
+     * // Iterate through all events
+     * for (const event of stats.eventList) {
+     *   console.log(`Signal ${event.signalId} reached breakeven at ${event.currentPrice}`);
+     * }
+     * ```
+     */
+    getData: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean) => Promise<BreakevenStatisticsModel>;
+    /**
+     * Generates markdown report with all breakeven events for a symbol-strategy pair.
+     *
+     * Creates formatted table containing:
+     * - Symbol
+     * - Strategy
+     * - Signal ID
+     * - Position (LONG/SHORT)
+     * - Entry Price
+     * - Breakeven Price
+     * - Timestamp (ISO 8601)
+     * - Mode (Backtest/Live)
+     *
+     * Also includes summary statistics at the end.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name (e.g., "my-strategy")
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise resolving to markdown formatted report string
+     *
+     * @example
+     * ```typescript
+     * const markdown = await Breakeven.getReport("BTCUSDT", "my-strategy");
+     * console.log(markdown);
+     *
+     * // Output:
+     * // # Breakeven Protection Report: BTCUSDT:my-strategy
+     * //
+     * // | Symbol | Strategy | Signal ID | Position | Entry Price | Breakeven Price | Timestamp | Mode |
+     * // | --- | --- | --- | --- | --- | --- | --- | --- |
+     * // | BTCUSDT | my-strategy | abc123 | LONG | 50000.00000000 USD | 50100.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
+     * //
+     * // **Total events:** 1
+     * ```
+     */
+    getReport: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, columns?: Columns[]) => Promise<string>;
+    /**
+     * Generates and saves markdown report to file.
+     *
+     * Creates directory if it doesn't exist.
+     * Filename format: {symbol}_{strategyName}.md (e.g., "BTCUSDT_my-strategy.md")
+     *
+     * Delegates to BreakevenMarkdownService.dump() which:
+     * 1. Generates markdown report via getReport()
+     * 2. Creates output directory (recursive mkdir)
+     * 3. Writes file with UTF-8 encoding
+     * 4. Logs success/failure to console
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name (e.g., "my-strategy")
+     * @param path - Output directory path (default: "./dump/breakeven")
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise that resolves when file is written
+     *
+     * @example
+     * ```typescript
+     * // Save to default path: ./dump/breakeven/BTCUSDT_my-strategy.md
+     * await Breakeven.dump("BTCUSDT", "my-strategy");
+     *
+     * // Save to custom path: ./reports/breakeven/BTCUSDT_my-strategy.md
+     * await Breakeven.dump("BTCUSDT", "my-strategy", "./reports/breakeven");
+     *
+     * // After multiple symbols backtested, export all reports
+     * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+     *   await Breakeven.dump(symbol, "my-strategy", "./backtest-results");
+     * }
      * ```
      */
-    clear(): Promise<void>;
+    dump: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, path?: string, columns?: Columns[]) => Promise<void>;
 }
 /**
- * Singleton instance of NotificationUtils for convenient notification access.
+ * Global singleton instance of BreakevenUtils.
+ * Provides static-like access to breakeven protection reporting methods.
  *
  * @example
  * ```typescript
- * import { Notification } from "./classes/Notification";
- *
- * // Get all notifications
- * const all = await Notification.getData();
- *
- * // Filter by type using type discrimination
- * const closedSignals = all.filter(n => n.type === "signal.closed");
- * const highLosses = all.filter(n =>
- *   n.type === "partial.loss" && n.level >= 30
- * );
+ * import { Breakeven } from "backtest-kit";
  *
- * // Clear history
- * await Notification.clear();
+ * // Usage same as BreakevenUtils methods
+ * const stats = await Breakeven.getData("BTCUSDT", "my-strategy");
+ * const report = await Breakeven.getReport("BTCUSDT", "my-strategy");
+ * await Breakeven.dump("BTCUSDT", "my-strategy");
  * ```
  */
-declare const Notification: NotificationUtils;
+declare const Breakeven: BreakevenUtils;
 
 /**
  * Contract for walker stop signal events.
@@ -9702,6 +10706,11 @@ declare const partialProfitSubject: Subject<PartialProfitContract>;
  * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
  */
 declare const partialLossSubject: Subject<PartialLossContract>;
+/**
+ * Breakeven emitter for stop-loss protection milestones.
+ * Emits when a signal's stop-loss is moved to breakeven (entry price).
+ */
+declare const breakevenSubject: Subject<BreakevenContract>;
 /**
  * Risk rejection emitter for risk management violations.
  * Emits ONLY when a signal is rejected due to risk validation failure.
@@ -9715,6 +10724,7 @@ declare const riskSubject: Subject<RiskContract>;
  */
 declare const pingSubject: Subject<PingContract>;
 
+declare const emitters_breakevenSubject: typeof breakevenSubject;
 declare const emitters_doneBacktestSubject: typeof doneBacktestSubject;
 declare const emitters_doneLiveSubject: typeof doneLiveSubject;
 declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
@@ -9736,7 +10746,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_pingSubject as pingSubject, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressOptimizerEmitter as progressOptimizerEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_pingSubject as pingSubject, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressOptimizerEmitter as progressOptimizerEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -10305,6 +11315,88 @@ declare class PartialConnectionService implements IPartial {
     clear: (symbol: string, data: ISignalRow, priceClose: number, backtest: boolean) => Promise<void>;
 }
 
+/**
+ * Connection service for breakeven tracking.
+ *
+ * Provides memoized ClientBreakeven instances per signal ID.
+ * Acts as factory and lifetime manager for ClientBreakeven objects.
+ *
+ * Features:
+ * - Creates one ClientBreakeven instance per signal ID (memoized)
+ * - Configures instances with logger and event emitter callbacks
+ * - Delegates check/clear operations to appropriate ClientBreakeven
+ * - Cleans up memoized instances when signals are cleared
+ *
+ * Architecture:
+ * - Injected into ClientStrategy via BreakevenGlobalService
+ * - Uses memoize from functools-kit for instance caching
+ * - Emits events to breakevenSubject
+ *
+ * @example
+ * ```typescript
+ * // Service injected via DI
+ * const service = inject<BreakevenConnectionService>(TYPES.breakevenConnectionService);
+ *
+ * // Called by ClientStrategy during signal monitoring
+ * await service.check("BTCUSDT", signal, 100.5, false, new Date());
+ * // Creates or reuses ClientBreakeven for signal.id
+ * // Delegates to ClientBreakeven.check()
+ *
+ * // When signal closes
+ * await service.clear("BTCUSDT", signal, 101, false);
+ * // Clears signal state and removes memoized instance
+ * ```
+ */
+declare class BreakevenConnectionService implements IBreakeven {
+    /**
+     * Logger service injected from DI container.
+     */
+    private readonly loggerService;
+    /**
+     * Memoized factory function for ClientBreakeven instances.
+     *
+     * Creates one ClientBreakeven per signal ID and backtest mode with configured callbacks.
+     * Instances are cached until clear() is called.
+     *
+     * Key format: "signalId:backtest" or "signalId:live"
+     * Value: ClientBreakeven instance with logger and event emitter
+     */
+    private getBreakeven;
+    /**
+     * Checks if breakeven should be triggered and emits event if conditions met.
+     *
+     * Retrieves or creates ClientBreakeven for signal ID, initializes it if needed,
+     * then delegates to ClientBreakeven.check() method.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param backtest - True if backtest mode, false if live mode
+     * @param when - Event timestamp (current time for live, candle time for backtest)
+     * @returns Promise that resolves when breakeven check is complete
+     */
+    check: (symbol: string, data: IPublicSignalRow, currentPrice: number, backtest: boolean, when: Date) => Promise<boolean>;
+    /**
+     * Clears breakeven state when signal closes.
+     *
+     * Retrieves ClientBreakeven for signal ID, initializes if needed,
+     * delegates clear operation, then removes memoized instance.
+     *
+     * Sequence:
+     * 1. Get ClientBreakeven from memoize cache
+     * 2. Ensure initialization (waitForInit)
+     * 3. Call ClientBreakeven.clear() - removes state, persists to disk
+     * 4. Clear memoized instance - prevents memory leaks
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param priceClose - Final closing price
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Promise that resolves when clear is complete
+     */
+    clear: (symbol: string, data: ISignalRow, priceClose: number, backtest: boolean) => Promise<void>;
+}
+
 /**
  * Type definition for strategy methods.
  * Maps all keys of IStrategy to any type.
@@ -10345,6 +11437,7 @@ declare class StrategyConnectionService implements TStrategy$1 {
     readonly riskConnectionService: RiskConnectionService;
     readonly exchangeConnectionService: ExchangeConnectionService;
     readonly partialConnectionService: PartialConnectionService;
+    readonly breakevenConnectionService: BreakevenConnectionService;
     /**
      * Retrieves memoized ClientStrategy instance for given symbol-strategy pair with exchange and frame isolation.
      *
@@ -10391,6 +11484,41 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<IScheduledSignalRow | null>;
+    /**
+     * Checks if breakeven threshold has been reached for the current pending signal.
+     *
+     * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+     * to cover transaction costs and allow breakeven to be set.
+     *
+     * Delegates to ClientStrategy.getBreakeven() with current execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check against threshold
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+     * const canBreakeven = await strategyConnectionService.getBreakeven(
+     *   false,
+     *   "BTCUSDT",
+     *   100.5,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * // Returns true (price >= 100.4)
+     *
+     * if (canBreakeven) {
+     *   await strategyConnectionService.breakeven(false, "BTCUSDT", 100.5, context);
+     * }
+     * ```
+     */
+    getBreakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Retrieves the stopped state of the strategy.
      *
@@ -10564,26 +11692,55 @@ declare class StrategyConnectionService implements TStrategy$1 {
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
      * @param context - Execution context with strategyName, exchangeName, frameName
      * @returns Promise that resolves when trailing SL is updated
      *
      * @example
      * ```typescript
-     * // LONG: entry=100, originalSL=90, distance=10
-     * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+     * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+     * // Tighten stop by 50%: newSL = 100 - 5% = 95
      * await strategyConnectionService.trailingStop(
      *   false,
      *   "BTCUSDT",
      *   -50,
+     *   102,
      *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
      * );
      * ```
      */
-    trailingStop: (backtest: boolean, symbol: string, percentShift: number, context: {
+    trailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Delegates to ClientStrategy.breakeven() with current execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check threshold
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven was set, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, slippage=0.1%, fee=0.1%, threshold=0.4%
+     * // Try to move SL to breakeven when price >= 100.4
+     * const moved = await strategyConnectionService.breakeven(
+     *   false,
+     *   "BTCUSDT",
+     *   100.5,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * console.log(moved); // true (SL moved to 100)
+     * ```
+     */
+    breakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
 }
 
 /**
@@ -10892,6 +12049,41 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<IScheduledSignalRow | null>;
+    /**
+     * Checks if breakeven threshold has been reached for the current pending signal.
+     *
+     * Validates strategy existence and delegates to connection service
+     * to check if price has moved far enough to cover transaction costs.
+     *
+     * Does not require execution context as this is a state query operation.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check against threshold
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+     * const canBreakeven = await strategyCoreService.getBreakeven(
+     *   false,
+     *   "BTCUSDT",
+     *   100.5,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * // Returns true (price >= 100.4)
+     *
+     * if (canBreakeven) {
+     *   await strategyCoreService.breakeven(false, "BTCUSDT", 100.5, context);
+     * }
+     * ```
+     */
+    getBreakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Checks if the strategy has been stopped.
      *
@@ -11067,26 +12259,53 @@ declare class StrategyCoreService implements TStrategy {
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
      * @param context - Execution context with strategyName, exchangeName, frameName
      * @returns Promise that resolves when trailing SL is updated
      *
      * @example
      * ```typescript
-     * // LONG: entry=100, originalSL=90, distance=10
-     * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+     * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+     * // Tighten stop by 50%: newSL = 100 - 5% = 95
      * await strategyCoreService.trailingStop(
      *   false,
      *   "BTCUSDT",
      *   -50,
+     *   102,
      *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
      * );
      * ```
      */
-    trailingStop: (backtest: boolean, symbol: string, percentShift: number, context: {
+    trailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Moves stop-loss to breakeven when price reaches threshold.
+     * Validates context and delegates to StrategyConnectionService.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check threshold
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven was set, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const moved = await strategyCoreService.breakeven(
+     *   false,
+     *   "BTCUSDT",
+     *   112,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * ```
+     */
+    breakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
 }
 
 /**
@@ -11164,6 +12383,7 @@ declare class RiskGlobalService implements TRisk {
     private readonly loggerService;
     private readonly riskConnectionService;
     private readonly riskValidationService;
+    private readonly exchangeValidationService;
     /**
      * Validates risk configuration.
      * Memoized to avoid redundant validations for the same risk-exchange-frame combination.
@@ -12654,6 +13874,10 @@ declare class PartialGlobalService implements TPartial {
      * Risk validation service for validating risk existence.
      */
     private readonly riskValidationService;
+    /**
+     * Exchange validation service for validating exchange existence.
+     */
+    private readonly exchangeValidationService;
     /**
      * Validates strategy and associated risk configuration.
      * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -12703,6 +13927,105 @@ declare class PartialGlobalService implements TPartial {
     clear: (symbol: string, data: ISignalRow, priceClose: number, backtest: boolean) => Promise<void>;
 }
 
+/**
+ * Type definition for breakeven methods.
+ * Maps all keys of IBreakeven to any type.
+ * Used for dynamic method routing in BreakevenGlobalService.
+ */
+type TBreakeven = {
+    [key in keyof IBreakeven]: any;
+};
+/**
+ * Global service for breakeven tracking.
+ *
+ * Thin delegation layer that forwards operations to BreakevenConnectionService.
+ * Provides centralized logging for all breakeven operations at the global level.
+ *
+ * Architecture:
+ * - Injected into ClientStrategy constructor via IStrategyParams
+ * - Delegates all operations to BreakevenConnectionService
+ * - Logs operations at "breakevenGlobalService" level before delegation
+ *
+ * Purpose:
+ * - Single injection point for ClientStrategy (dependency injection pattern)
+ * - Centralized logging for monitoring breakeven operations
+ * - Layer of abstraction between strategy and connection layer
+ *
+ * @example
+ * ```typescript
+ * // Service injected into ClientStrategy via DI
+ * const strategy = new ClientStrategy({
+ *   breakeven: breakevenGlobalService,
+ *   ...
+ * });
+ *
+ * // Called during signal monitoring
+ * await strategy.params.breakeven.check("BTCUSDT", signal, 100.5, false, new Date());
+ * // Logs at global level → delegates to BreakevenConnectionService
+ * ```
+ */
+declare class BreakevenGlobalService implements TBreakeven {
+    /**
+     * Logger service injected from DI container.
+     * Used for logging operations at global service level.
+     */
+    private readonly loggerService;
+    /**
+     * Connection service injected from DI container.
+     * Handles actual ClientBreakeven instance creation and management.
+     */
+    private readonly breakevenConnectionService;
+    /**
+     * Strategy validation service for validating strategy existence.
+     */
+    private readonly strategyValidationService;
+    /**
+     * Strategy schema service for retrieving strategy configuration.
+     */
+    private readonly strategySchemaService;
+    /**
+     * Risk validation service for validating risk existence.
+     */
+    private readonly riskValidationService;
+    /**
+     * Exchange validation service for validating exchange existence.
+     */
+    private readonly exchangeValidationService;
+    /**
+     * Validates strategy and associated risk configuration.
+     * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
+     *
+     * @param context - Context with strategyName, exchangeName and frameName
+     * @param methodName - Name of the calling method for error tracking
+     */
+    private validate;
+    /**
+     * Checks if breakeven should be triggered and emits event if conditions met.
+     *
+     * Logs operation at global service level, then delegates to BreakevenConnectionService.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param currentPrice - Current market price
+     * @param backtest - True if backtest mode, false if live mode
+     * @param when - Event timestamp (current time for live, candle time for backtest)
+     * @returns Promise that resolves when breakeven check is complete
+     */
+    check: (symbol: string, data: IPublicSignalRow, currentPrice: number, backtest: boolean, when: Date) => Promise<boolean>;
+    /**
+     * Clears breakeven state when signal closes.
+     *
+     * Logs operation at global service level, then delegates to BreakevenConnectionService.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param data - Signal row data
+     * @param priceClose - Final closing price
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Promise that resolves when clear is complete
+     */
+    clear: (symbol: string, data: ISignalRow, priceClose: number, backtest: boolean) => Promise<void>;
+}
+
 /**
  * Unique identifier for outline result.
  * Can be string or number for flexible ID formats.
@@ -12867,6 +14190,7 @@ declare const backtest: {
     walkerMarkdownService: WalkerMarkdownService;
     heatMarkdownService: HeatMarkdownService;
     partialMarkdownService: PartialMarkdownService;
+    breakevenMarkdownService: BreakevenMarkdownService;
     outlineMarkdownService: OutlineMarkdownService;
     riskMarkdownService: RiskMarkdownService;
     backtestLogicPublicService: BacktestLogicPublicService;
@@ -12882,6 +14206,7 @@ declare const backtest: {
     riskGlobalService: RiskGlobalService;
     optimizerGlobalService: OptimizerGlobalService;
     partialGlobalService: PartialGlobalService;
+    breakevenGlobalService: BreakevenGlobalService;
     exchangeCoreService: ExchangeCoreService;
     strategyCoreService: StrategyCoreService;
     frameCoreService: FrameCoreService;
@@ -12899,6 +14224,7 @@ declare const backtest: {
     riskConnectionService: RiskConnectionService;
     optimizerConnectionService: OptimizerConnectionService;
     partialConnectionService: PartialConnectionService;
+    breakevenConnectionService: BreakevenConnectionService;
     executionContextService: {
         readonly context: IExecutionContext;
     };
@@ -12908,4 +14234,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { Backtest, type BacktestDoneNotification, type BacktestStatisticsModel, type BootstrapNotification, Cache, type CandleInterval, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IOptimizerCallbacks, type IOptimizerData, type IOptimizerFetchArgs, type IOptimizerFilterArgs, type IOptimizerRange, type IOptimizerSchema, type IOptimizerSource, type IOptimizerStrategy, type IOptimizerTemplate, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicSignalRow, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveDoneNotification, type LiveStatisticsModel, type MessageModel, type MessageRole, MethodContextService, type MetricStats, Notification, type NotificationModel, Optimizer, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossContract, type PartialLossNotification, type PartialProfitContract, type PartialProfitNotification, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, type PingContract, PositionSize, type ProgressBacktestContract, type ProgressBacktestNotification, type ProgressOptimizerContract, type ProgressWalkerContract, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, type TPersistBase, type TPersistBaseCtor, type TickEvent, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, trailingStop, validate };
+export { Backtest, type BacktestDoneNotification, type BacktestStatisticsModel, type BootstrapNotification, Breakeven, type BreakevenContract, type BreakevenData, Cache, type CandleInterval, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IOptimizerCallbacks, type IOptimizerData, type IOptimizerFetchArgs, type IOptimizerFilterArgs, type IOptimizerRange, type IOptimizerSchema, type IOptimizerSource, type IOptimizerStrategy, type IOptimizerTemplate, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicSignalRow, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveDoneNotification, type LiveStatisticsModel, type MessageModel, type MessageRole, MethodContextService, type MetricStats, Notification, type NotificationModel, Optimizer, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossContract, type PartialLossNotification, type PartialProfitContract, type PartialProfitNotification, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, type PingContract, PositionSize, type ProgressBacktestContract, type ProgressBacktestNotification, type ProgressOptimizerContract, type ProgressWalkerContract, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, type TPersistBase, type TPersistBaseCtor, type TickEvent, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, breakeven, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenBreakeven, listenBreakevenOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, trailingStop, validate };