backtest-kit 5.5.3 → 5.6.1

package/types.d.ts

@@ -2216,6 +2216,19 @@ interface ISignalRow extends ISignalDto {
      * Original priceTakeProfit is preserved in persistence but ignored during execution.
      */
     _trailingPriceTakeProfit?: number;
+    /**
+     * Best price seen in profit direction during the life of this position.
+     * Initialized at position open with priceOpen/pendingAt.
+     * Updated on every tick/candle when price moves toward TP (currentDistance > 0).
+     * - For LONG: maximum VWAP price seen above effective entry
+     * - For SHORT: minimum VWAP price seen below effective entry
+     */
+    _peak: {
+        price: number;
+        timestamp: number;
+        pnlPercentage: number;
+        pnlCost: number;
+    };
     /** Unix timestamp in milliseconds when this signal was created/scheduled in backtest context or when getSignal was called in live context (before validation) */
     timestamp: number;
 }
@@ -2844,7 +2857,7 @@ interface IStrategy {
      * Returns the effective (DCA-averaged) entry price for the current pending signal.
      * Returns null if no pending signal exists.
      */
-    getPositionAveragePrice: (symbol: string) => Promise<number | null>;
+    getPositionEffectivePrice: (symbol: string) => Promise<number | null>;
     /**
      * Returns the number of DCA entries for the current pending signal.
      * 1 = original entry only. Returns null if no pending signal exists.
@@ -3386,6 +3399,91 @@ interface IStrategy {
      * @returns Promise resolving to true if pending signal exists, false otherwise
      */
     hasPendingSignal: (symbol: string) => Promise<boolean>;
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+     * number of minutes the position is expected to be active before `time_expired`.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to estimated duration in minutes or null
+     */
+    getPositionEstimateMinutes: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+     * Returns 0 once the estimate is exceeded (never negative).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to remaining minutes (≥ 0) or null
+     */
+    getPositionCountdownMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to price or null
+     */
+    getPositionHighestProfitPrice: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionHighestPnlPercentage: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionHighestPnlCost: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionHighestProfitTimestamp: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     *
+     * Uses the same threshold formula as getBreakeven with the recorded peak price.
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+     */
+    getPositionHighestProfitBreakeven: (symbol: string) => Promise<boolean | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Measures how long the position has been pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     * Grows continuously as price moves away from the peak without setting a new record.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to drawdown duration in minutes or null
+     */
+    getPositionDrawdownMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
     /**
      * Disposes the strategy instance and cleans up resources.
      *
@@ -4830,14 +4928,14 @@ declare function getBreakeven(symbol: string, currentPrice: number): Promise<boo
  *
  * @example
  * ```typescript
- * import { getPositionAveragePrice } from "backtest-kit";
+ * import { getPositionEffectivePrice } from "backtest-kit";
  *
- * const avgPrice = await getPositionAveragePrice("BTCUSDT");
+ * const avgPrice = await getPositionEffectivePrice("BTCUSDT");
  * // No DCA: avgPrice === priceOpen
  * // After DCA at lower price: avgPrice < priceOpen
  * ```
  */
-declare function getPositionAveragePrice(symbol: string): Promise<number | null>;
+declare function getPositionEffectivePrice(symbol: string): Promise<number | null>;
 /**
  * Returns the number of DCA entries made for the current pending signal.
  *
@@ -5050,6 +5148,189 @@ declare function getPositionPartials(symbol: string): Promise<{
     entryCountAtClose: number;
     timestamp: number;
 }[]>;
+/**
+ * Returns the list of DCA entry prices and costs for the current pending signal.
+ *
+ * Each element represents a single position entry — the initial open or a subsequent
+ * DCA entry added via commitAverageBuy.
+ *
+ * Returns null if no pending signal exists.
+ * Returns a single-element array if no DCA entries were made.
+ *
+ * Each entry contains:
+ * - `price` — execution price of this entry
+ * - `cost` — dollar cost allocated to this entry (e.g. 100 for $100)
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to array of entry records or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionEntries } from "backtest-kit";
+ *
+ * const entries = await getPositionEntries("BTCUSDT");
+ * // No DCA: [{ price: 43000, cost: 100 }]
+ * // One DCA: [{ price: 43000, cost: 100 }, { price: 42000, cost: 100 }]
+ * ```
+ */
+declare function getPositionEntries(symbol: string): Promise<{
+    price: number;
+    cost: number;
+    timestamp: number;
+}[]>;
+/**
+ * Returns the original estimated duration for the current pending signal.
+ *
+ * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+ * number of minutes the position is expected to be active before `time_expired`.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to estimated duration in minutes or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionEstimateMinutes } from "backtest-kit";
+ *
+ * const estimate = await getPositionEstimateMinutes("BTCUSDT");
+ * // e.g. 120 (2 hours)
+ * ```
+ */
+declare function getPositionEstimateMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the remaining time before the position expires, clamped to zero.
+ *
+ * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+ * Returns 0 once the estimate is exceeded (never negative).
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to remaining minutes (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionCountdownMinutes } from "backtest-kit";
+ *
+ * const remaining = await getPositionCountdownMinutes("BTCUSDT");
+ * // e.g. 45 (45 minutes left)
+ * // 0 when expired
+ * ```
+ */
+declare function getPositionCountdownMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the best price reached in the profit direction during this position's life.
+ *
+ * Initialized at position open with the entry price and timestamp.
+ * Updated on every tick/candle when VWAP moves beyond the previous record toward TP:
+ * - LONG: tracks the highest price seen above effective entry
+ * - SHORT: tracks the lowest price seen below effective entry
+ *
+ * Returns null if no pending signal exists.
+ * Never returns null when a signal is active — always contains at least the entry price.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to `{ price, timestamp }` record or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitPrice } from "backtest-kit";
+ *
+ * const peak = await getPositionHighestProfitPrice("BTCUSDT");
+ * // e.g. { price: 44500, timestamp: 1700000000000 }
+ * ```
+ */
+declare function getPositionHighestProfitPrice(symbol: string): Promise<number>;
+/**
+ * Returns the timestamp when the best profit price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to timestamp in milliseconds or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitTimestamp } from "backtest-kit";
+ *
+ * const ts = await getPositionHighestProfitTimestamp("BTCUSDT");
+ * // e.g. 1700000000000
+ * ```
+ */
+declare function getPositionHighestProfitTimestamp(symbol: string): Promise<number>;
+/**
+ * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL percentage or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestPnlPercentage } from "backtest-kit";
+ *
+ * const pnl = await getPositionHighestPnlPercentage("BTCUSDT");
+ * // e.g. 3.5
+ * ```
+ */
+declare function getPositionHighestPnlPercentage(symbol: string): Promise<number>;
+/**
+ * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL cost or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestPnlCost } from "backtest-kit";
+ *
+ * const pnlCost = await getPositionHighestPnlCost("BTCUSDT");
+ * // e.g. 35.5
+ * ```
+ */
+declare function getPositionHighestPnlCost(symbol: string): Promise<number>;
+/**
+ * Returns whether breakeven was mathematically reachable at the highest profit price.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitBreakeven } from "backtest-kit";
+ *
+ * const couldBreakeven = await getPositionHighestProfitBreakeven("BTCUSDT");
+ * // e.g. true (price reached the breakeven threshold at its peak)
+ * ```
+ */
+declare function getPositionHighestProfitBreakeven(symbol: string): Promise<boolean>;
+/**
+ * Returns the number of minutes elapsed since the highest profit price was recorded.
+ *
+ * Measures how long the position has been pulling back from its peak profit level.
+ * Zero when called at the exact moment the peak was set.
+ * Grows continuously as price moves away from the peak without setting a new record.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to drawdown duration in minutes or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionDrawdownMinutes } from "backtest-kit";
+ *
+ * const drawdown = await getPositionDrawdownMinutes("BTCUSDT");
+ * // e.g. 30 (30 minutes since the highest profit price)
+ * ```
+ */
+declare function getPositionDrawdownMinutes(symbol: string): Promise<number>;
 /**
  * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
  * Use this to prevent duplicate DCA entries at the same price area.
@@ -5133,72 +5414,6 @@ declare function stopStrategy(symbol: string): Promise<void>;
  */
 declare function shutdown(): void;
 
-/**
- * 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;
-    /** Take profit target price */
-    priceTakeProfit?: number;
-    /** Stop loss exit price */
-    priceStopLoss?: number;
-    /** Original take profit price set at signal creation */
-    originalPriceTakeProfit?: number;
-    /** Original stop loss price set at signal creation */
-    originalPriceStopLoss?: number;
-    /** Total number of DCA entries (present when averageBuy was applied) */
-    totalEntries?: number;
-    /** Total number of partial closes executed (_partial.length) */
-    totalPartials?: number;
-    /** Original entry price before DCA averaging (present when averageBuy was applied) */
-    originalPriceOpen?: number;
-    /** Total executed percentage from partial closes */
-    partialExecuted?: number;
-    /** Unrealized PNL at the moment breakeven was reached */
-    pnl?: IStrategyPnL;
-    /** Human-readable description of signal reason */
-    note?: string;
-    /** Timestamp when position became active (ms) */
-    pendingAt?: number;
-    /** Timestamp when signal was created/scheduled (ms) */
-    scheduledAt?: 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)
@@ -5435,6 +5650,8 @@ declare const COLUMN_CONFIG: {
     strategy_columns: ColumnModel<StrategyEvent>[];
     /** Columns for signal sync lifecycle events (signal-open, signal-close) */
     sync_columns: ColumnModel<SyncEvent>[];
+    /** Columns for highest profit milestone tracking events */
+    highest_profit_columns: ColumnModel<HighestProfitEvent>[];
     /** Walker: PnL summary columns */
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     /** Walker: strategy-level summary columns */
@@ -5611,6 +5828,7 @@ declare function getColumns(): {
     schedule_columns: ColumnModel<ScheduledEvent>[];
     strategy_columns: ColumnModel<StrategyEvent>[];
     sync_columns: ColumnModel<SyncEvent>[];
+    highest_profit_columns: ColumnModel<HighestProfitEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 };
@@ -5639,6 +5857,7 @@ declare function getDefaultColumns(): Readonly<{
     schedule_columns: ColumnModel<ScheduledEvent>[];
     strategy_columns: ColumnModel<StrategyEvent>[];
     sync_columns: ColumnModel<SyncEvent>[];
+    highest_profit_columns: ColumnModel<HighestProfitEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 }>;
@@ -6686,6 +6905,32 @@ interface WalkerContract {
     totalStrategies: number;
 }
 
+/**
+ * Contract for highest profit updates emitted by the framework.
+ * This contract defines the structure of the data emitted when a new highest profit is achieved for an open position.
+ * It includes contextual information about the strategy, exchange, frame, and the associated signal.
+ * Consumers can use this information to implement custom logic based on profit milestones (e.g. trailing stops, partial profit-taking).
+ * The backtest flag allows consumers to differentiate between live and backtest updates for appropriate handling.
+ */
+interface HighestProfitContract {
+    /** Trading symbol (e.g. "BTC/USDT") */
+    symbol: string;
+    /** Current price at the time of the highest profit update */
+    currentPrice: number;
+    /** Timestamp of the highest profit update (milliseconds since epoch) */
+    timestamp: number;
+    /** Strategy name for context */
+    strategyName: StrategyName;
+    /** Exchange name for context */
+    exchangeName: ExchangeName;
+    /** Frame name for context (e.g. "1m", "5m") */
+    frameName: FrameName;
+    /** Public signal data for the position associated with this highest profit update */
+    signal: IPublicSignalRow;
+    /** Indicates if the update is from a backtest or live trading (true for backtest, false for live) */
+    backtest: boolean;
+}
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -7701,15 +7946,36 @@ declare function listenSync(fn: (event: SignalSyncContract) => void): () => void
  * @returns Unsubscribe function to cancel the listener before it fires
  */
 declare function listenSyncOnce(filterFn: (event: SignalSyncContract) => boolean, fn: (event: SignalSyncContract) => void): () => void;
-
 /**
- * Checks if trade context is active (execution and method contexts).
+ * Subscribes to highest profit events with queued async processing.
+ * Emits when a signal reaches a new highest profit level during its lifecycle.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * Useful for tracking profit milestones and implementing dynamic management logic.
  *
- * Returns true when both contexts are active, which is required for calling
- * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
- * getDate, and getMode.
+ * @param fn - Callback function to handle highest profit events
+ * @return Unsubscribe function to stop listening to events
+ */
+declare function listenHighestProfit(fn: (event: HighestProfitContract) => void): () => void;
+/**
+ * Subscribes to filtered highest profit events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific profit conditions.
  *
- * @returns true if trade context is active, false otherwise
+ * @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
+ */
+declare function listenHighestProfitOnce(filterFn: (event: HighestProfitContract) => boolean, fn: (event: HighestProfitContract) => void): () => void;
+
+/**
+ * Checks if trade context is active (execution and method contexts).
+ *
+ * Returns true when both contexts are active, which is required for calling
+ * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
+ * getDate, and getMode.
+ *
+ * @returns true if trade context is active, false otherwise
  *
  * @example
  * ```typescript
@@ -9660,6 +9926,43 @@ interface PartialStatisticsModel {
     totalLoss: number;
 }
 
+/**
+ * Single highest profit event recorded for a position.
+ */
+interface HighestProfitEvent {
+    /** Unix timestamp in milliseconds when the record was set */
+    timestamp: number;
+    /** Trading pair symbol */
+    symbol: string;
+    /** Strategy name */
+    strategyName: string;
+    /** Signal unique identifier */
+    signalId: string;
+    /** Position direction */
+    position: IPublicSignalRow["position"];
+    /** Unrealized PNL at the time the record was set */
+    pnl: IStrategyPnL;
+    /** Record price reached in the profit direction */
+    currentPrice: number;
+    /** Effective entry price at the time of the update */
+    priceOpen: number;
+    /** Take profit price */
+    priceTakeProfit: number;
+    /** Stop loss price */
+    priceStopLoss: number;
+    /** Whether the event occurred in backtest mode */
+    backtest: boolean;
+}
+/**
+ * Aggregated statistics model for highest profit events.
+ */
+interface HighestProfitStatisticsModel {
+    /** Full list of recorded events (newest first) */
+    eventList: HighestProfitEvent[];
+    /** Total number of recorded events */
+    totalEvents: number;
+}
+
 /**
  * Risk rejection event data for report generation.
  * Contains all information about rejected signals due to risk limits.
@@ -9712,6 +10015,72 @@ interface RiskStatisticsModel {
     byStrategy: Record<string, number>;
 }
 
+/**
+ * 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;
+    /** Take profit target price */
+    priceTakeProfit?: number;
+    /** Stop loss exit price */
+    priceStopLoss?: number;
+    /** Original take profit price set at signal creation */
+    originalPriceTakeProfit?: number;
+    /** Original stop loss price set at signal creation */
+    originalPriceStopLoss?: number;
+    /** Total number of DCA entries (present when averageBuy was applied) */
+    totalEntries?: number;
+    /** Total number of partial closes executed (_partial.length) */
+    totalPartials?: number;
+    /** Original entry price before DCA averaging (present when averageBuy was applied) */
+    originalPriceOpen?: number;
+    /** Total executed percentage from partial closes */
+    partialExecuted?: number;
+    /** Unrealized PNL at the moment breakeven was reached */
+    pnl?: IStrategyPnL;
+    /** Human-readable description of signal reason */
+    note?: string;
+    /** Timestamp when position became active (ms) */
+    pendingAt?: number;
+    /** Timestamp when signal was created/scheduled (ms) */
+    scheduledAt?: 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;
+}
+
 /**
  * Action types for strategy events.
  * Represents all possible strategy management actions.
@@ -10781,6 +11150,8 @@ interface IReportTarget {
     backtest: boolean;
     /** Enable signal synchronization event logging (signal-open, signal-close) */
     sync: boolean;
+    /** Enable highest profit milestone event logging */
+    highest_profit: boolean;
 }
 /**
  * Union type of all valid report names.
@@ -10932,7 +11303,7 @@ declare class ReportUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, }?: Partial<IReportTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, }?: Partial<IReportTarget>) => (...args: any[]) => any;
     /**
      * Disables report services selectively.
      *
@@ -10969,7 +11340,7 @@ declare class ReportUtils {
      * Report.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, }?: Partial<IReportTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, }?: Partial<IReportTarget>) => void;
 }
 /**
  * Report adapter with pluggable storage backend and instance memoization.
@@ -11061,6 +11432,8 @@ interface IMarkdownTarget {
     backtest: boolean;
     /** Enable signal sync lifecycle reports (signal-open and signal-close events) */
     sync: boolean;
+    /** Enable highest profit milestone tracking reports */
+    highest_profit: boolean;
 }
 declare const WAIT_FOR_INIT_SYMBOL: unique symbol;
 declare const WRITE_SAFE_SYMBOL: unique symbol;
@@ -11256,7 +11629,7 @@ declare class MarkdownUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, sync, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, sync, highest_profit, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
     /**
      * Disables markdown report services selectively.
      *
@@ -11294,7 +11667,7 @@ declare class MarkdownUtils {
      * Markdown.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, sync, }?: Partial<IMarkdownTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, sync, highest_profit, }?: Partial<IMarkdownTarget>) => void;
 }
 /**
  * Markdown adapter with pluggable storage backend and instance memoization.
@@ -11494,7 +11867,7 @@ declare const Log: LogAdapter;
  * @see ColumnModel for the base interface
  * @see IStrategyTickResultClosed for the signal data structure
  */
-type Columns$9 = ColumnModel<IStrategyTickResultClosed>;
+type Columns$a = ColumnModel<IStrategyTickResultClosed>;
 /**
  * Service for generating and saving backtest markdown reports.
  *
@@ -11588,7 +11961,7 @@ declare class BacktestMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$9[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$a[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -11613,7 +11986,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$9[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$a[]) => Promise<void>;
     /**
      * Clears accumulated signal data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -11852,7 +12225,7 @@ declare class BacktestUtils {
      * @param context - Execution context with strategyName, exchangeName, and frameName
      * @returns Effective entry price, or null if no active position
      */
-    getPositionAveragePrice: (symbol: string, context: {
+    getPositionEffectivePrice: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -11991,6 +12364,126 @@ declare class BacktestUtils {
         cost: number;
         timestamp: number;
     }[]>;
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+     * number of minutes the position is expected to be active before `time_expired`.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Estimated duration in minutes, or null if no active position
+     */
+    getPositionEstimateMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+     * Returns 0 once the estimate is exceeded (never negative).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Remaining minutes (≥ 0), or null if no active position
+     */
+    getPositionCountdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns price or null if no active position
+     */
+    getPositionHighestProfitPrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns timestamp in milliseconds or null if no active position
+     */
+    getPositionHighestProfitTimestamp: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL percentage or null if no active position
+     */
+    getPositionHighestPnlPercentage: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL cost or null if no active position
+     */
+    getPositionHighestPnlCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns true if breakeven was reachable at peak, false otherwise, or null if no active position
+     */
+    getPositionHighestProfitBreakeven: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Measures how long the position has been pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     * Grows continuously as price moves away from the peak without setting a new record.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Drawdown duration in minutes, or null if no active position
+     */
+    getPositionDrawdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
     /**
      * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
      * Use this to prevent duplicate DCA entries at the same price area.
@@ -12508,7 +13001,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, columns?: Columns$9[]) => Promise<string>;
+    }, columns?: Columns$a[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -12539,7 +13032,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, path?: string, columns?: Columns$9[]) => Promise<void>;
+    }, path?: string, columns?: Columns$a[]) => Promise<void>;
     /**
      * Lists all active backtest instances with their current status.
      *
@@ -12613,7 +13106,7 @@ declare const Backtest: BacktestUtils;
  * @see ColumnModel for the base interface
  * @see TickEvent for the event data structure
  */
-type Columns$8 = ColumnModel<TickEvent>;
+type Columns$9 = ColumnModel<TickEvent>;
 /**
  * Service for generating and saving live trading markdown reports.
  *
@@ -12740,7 +13233,7 @@ declare class LiveMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$8[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$9[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -12765,7 +13258,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$8[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -12981,7 +13474,7 @@ declare class LiveUtils {
      * @param context - Execution context with strategyName and exchangeName
      * @returns Effective entry price, or null if no active position
      */
-    getPositionAveragePrice: (symbol: string, context: {
+    getPositionEffectivePrice: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number | null>;
@@ -13112,6 +13605,118 @@ declare class LiveUtils {
         cost: number;
         timestamp: number;
     }[]>;
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+     * number of minutes the position is expected to be active before `time_expired`.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Estimated duration in minutes, or null if no active position
+     */
+    getPositionEstimateMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+     * Returns 0 once the estimate is exceeded (never negative).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Remaining minutes (≥ 0), or null if no active position
+     */
+    getPositionCountdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns price or null if no active position
+     */
+    getPositionHighestProfitPrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns timestamp in milliseconds or null if no active position
+     */
+    getPositionHighestProfitTimestamp: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL percentage or null if no active position
+     */
+    getPositionHighestPnlPercentage: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL cost or null if no active position
+     */
+    getPositionHighestPnlCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns true if breakeven was reachable at peak, false otherwise, or null if no active position
+     */
+    getPositionHighestProfitBreakeven: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Measures how long the position has been pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     * Grows continuously as price moves away from the peak without setting a new record.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Drawdown duration in minutes, or null if no active position
+     */
+    getPositionDrawdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
     /**
      * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
      * Use this to prevent duplicate DCA entries at the same price area.
@@ -13597,7 +14202,7 @@ declare class LiveUtils {
     getReport: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, columns?: Columns$8[]) => Promise<string>;
+    }, columns?: Columns$9[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -13627,7 +14232,7 @@ declare class LiveUtils {
     dump: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, path?: string, columns?: Columns$8[]) => Promise<void>;
+    }, path?: string, columns?: Columns$9[]) => Promise<void>;
     /**
      * Lists all active live trading instances with their current status.
      *
@@ -13697,7 +14302,7 @@ declare const Live: LiveUtils;
  * @see ColumnModel for the base interface
  * @see ScheduledEvent for the event data structure
  */
-type Columns$7 = ColumnModel<ScheduledEvent>;
+type Columns$8 = ColumnModel<ScheduledEvent>;
 /**
  * Service for generating and saving scheduled signals markdown reports.
  *
@@ -13808,7 +14413,7 @@ declare class ScheduleMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$8[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -13833,7 +14438,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$7[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -13923,7 +14528,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$7[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$8[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -13945,7 +14550,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
 }
 /**
  * Singleton instance of ScheduleUtils for convenient scheduled signals reporting.
@@ -13991,7 +14596,7 @@ declare const Schedule: ScheduleUtils;
  * @see ColumnModel for the base interface
  * @see MetricStats for the metric data structure
  */
-type Columns$6 = ColumnModel<MetricStats>;
+type Columns$7 = ColumnModel<MetricStats>;
 /**
  * Service for collecting and analyzing performance metrics.
  *
@@ -14098,7 +14703,7 @@ declare class PerformanceMarkdownService {
      * 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 performance report to disk.
      *
@@ -14119,7 +14724,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$6[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Clears accumulated performance data from storage.
      *
@@ -14227,7 +14832,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$6[]): Promise<string>;
+    }, backtest?: boolean, columns?: Columns$7[]): Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -14252,7 +14857,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$6[]): Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$7[]): Promise<void>;
 }
 
 /**
@@ -14683,7 +15288,7 @@ declare const Walker: WalkerUtils;
  * @see ColumnModel for the base interface
  * @see IHeatmapRow for the row data structure
  */
-type Columns$5 = ColumnModel<IHeatmapRow>;
+type Columns$6 = ColumnModel<IHeatmapRow>;
 /**
  * Portfolio Heatmap Markdown Service.
  *
@@ -14804,7 +15409,7 @@ declare class HeatMarkdownService {
      * // ...
      * ```
      */
-    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
+    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves heatmap report to disk.
      *
@@ -14829,7 +15434,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$5[]) => Promise<void>;
+    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
      * Clears accumulated heatmap data from storage.
      * If payload is provided, clears only that exchangeName+frameName+backtest combination's data.
@@ -14959,7 +15564,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves heatmap report to disk for a strategy.
      *
@@ -14992,7 +15597,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
 }
 /**
  * Singleton instance of HeatUtils for convenient heatmap operations.
@@ -15146,7 +15751,7 @@ declare const PositionSize: typeof PositionSizeUtils;
  * @see ColumnModel for the base interface
  * @see PartialEvent for the event data structure
  */
-type Columns$4 = ColumnModel<PartialEvent>;
+type Columns$5 = ColumnModel<PartialEvent>;
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -15268,7 +15873,7 @@ declare class PartialMarkdownService {
      * 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.
@@ -15293,7 +15898,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$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.
@@ -15403,27 +16008,153 @@ declare class PartialUtils {
      * 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
+     * @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 Partial.getReport("BTCUSDT", "my-strategy");
+     * console.log(markdown);
+     *
+     * // Output:
+     * // # Partial Profit/Loss Report: BTCUSDT:my-strategy
+     * //
+     * // | Action | Symbol | Strategy | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
+     * // | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+     * // | PROFIT | BTCUSDT | my-strategy | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
+     * // | LOSS | BTCUSDT | my-strategy | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
+     * //
+     * // **Total events:** 2
+     * // **Profit events:** 1
+     * // **Loss events:** 1
+     * ```
+     */
+    getReport: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, columns?: Columns$5[]) => 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 PartialMarkdownService.dump() which:
+     * 1. Generates markdown report via getReport()
+     * 2. Creates output directory (recursive mkdir)
+     * 3. Writes file with UTF-8 encoding
+     * 4. Logs success/failure to console
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name (e.g., "my-strategy")
+     * @param path - Output directory path (default: "./dump/partial")
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise that resolves when file is written
+     *
+     * @example
+     * ```typescript
+     * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
+     * await Partial.dump("BTCUSDT", "my-strategy");
+     *
+     * // Save to custom path: ./reports/partial/BTCUSDT_my-strategy.md
+     * await Partial.dump("BTCUSDT", "my-strategy", "./reports/partial");
+     *
+     * // After multiple symbols backtested, export all reports
+     * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+     *   await Partial.dump(symbol, "my-strategy", "./backtest-results");
+     * }
+     * ```
+     */
+    dump: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+}
+/**
+ * Global singleton instance of PartialUtils.
+ * Provides static-like access to partial profit/loss reporting methods.
+ *
+ * @example
+ * ```typescript
+ * import { Partial } from "backtest-kit";
+ *
+ * // Usage same as PartialUtils methods
+ * const stats = await Partial.getData("BTCUSDT", "my-strategy");
+ * const report = await Partial.getReport("BTCUSDT", "my-strategy");
+ * await Partial.dump("BTCUSDT", "my-strategy");
+ * ```
+ */
+declare const Partial$1: PartialUtils;
+
+/**
+ * Type alias for column configuration used in highest profit markdown reports.
+ */
+type Columns$4 = ColumnModel<HighestProfitEvent>;
+/**
+ * Service for generating and saving highest profit markdown reports.
+ *
+ * Listens to highestProfitSubject and accumulates events per
+ * symbol-strategy-exchange-frame combination. Provides getData(),
+ * getReport(), and dump() methods matching the Partial pattern.
+ */
+declare class HighestProfitMarkdownService {
+    private readonly loggerService;
+    private getStorage;
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    unsubscribe: () => Promise<void>;
+    private tick;
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<HighestProfitStatisticsModel>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    clear: (payload?: {
+        symbol: string;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+        backtest: boolean;
+    }) => Promise<void>;
+}
+
+/**
+ * Utility class for accessing highest profit reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by HighestProfitMarkdownService from highestProfitSubject events.
+ *
+ * @example
+ * ```typescript
+ * import { HighestProfit } from "backtest-kit";
+ *
+ * const stats = await HighestProfit.getData("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const report = await HighestProfit.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
+ * await HighestProfit.dump("BTCUSDT", { strategyName, exchangeName, frameName });
+ * ```
+ */
+declare class HighestProfitUtils {
+    /**
+     * Retrieves statistical data from accumulated highest profit events.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @returns Promise resolving to HighestProfitStatisticsModel
+     */
+    getData: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean) => Promise<HighestProfitStatisticsModel>;
+    /**
+     * Generates a markdown report with all highest profit events for a symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @param columns - Optional column configuration
      * @returns Promise resolving to markdown formatted report string
-     *
-     * @example
-     * ```typescript
-     * const markdown = await Partial.getReport("BTCUSDT", "my-strategy");
-     * console.log(markdown);
-     *
-     * // Output:
-     * // # Partial Profit/Loss Report: BTCUSDT:my-strategy
-     * //
-     * // | Action | Symbol | Strategy | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
-     * // | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-     * // | PROFIT | BTCUSDT | my-strategy | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
-     * // | LOSS | BTCUSDT | my-strategy | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
-     * //
-     * // **Total events:** 2
-     * // **Profit events:** 1
-     * // **Loss events:** 1
-     * ```
      */
     getReport: (symbol: string, context: {
         strategyName: StrategyName;
@@ -15431,36 +16162,13 @@ declare class PartialUtils {
         frameName: FrameName;
     }, backtest?: boolean, columns?: Columns$4[]) => 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 PartialMarkdownService.dump() which:
-     * 1. Generates markdown report via getReport()
-     * 2. Creates output directory (recursive mkdir)
-     * 3. Writes file with UTF-8 encoding
-     * 4. Logs success/failure to console
+     * Generates and saves a markdown report to file.
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param strategyName - Strategy name (e.g., "my-strategy")
-     * @param path - Output directory path (default: "./dump/partial")
-     * @param columns - Optional columns configuration for the report
-     * @returns Promise that resolves when file is written
-     *
-     * @example
-     * ```typescript
-     * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
-     * await Partial.dump("BTCUSDT", "my-strategy");
-     *
-     * // Save to custom path: ./reports/partial/BTCUSDT_my-strategy.md
-     * await Partial.dump("BTCUSDT", "my-strategy", "./reports/partial");
-     *
-     * // After multiple symbols backtested, export all reports
-     * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
-     *   await Partial.dump(symbol, "my-strategy", "./backtest-results");
-     * }
-     * ```
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @param path - Output directory path (default: "./dump/highest_profit")
+     * @param columns - Optional column configuration
      */
     dump: (symbol: string, context: {
         strategyName: StrategyName;
@@ -15469,20 +16177,9 @@ declare class PartialUtils {
     }, backtest?: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
 }
 /**
- * Global singleton instance of PartialUtils.
- * Provides static-like access to partial profit/loss reporting methods.
- *
- * @example
- * ```typescript
- * import { Partial } from "backtest-kit";
- *
- * // Usage same as PartialUtils methods
- * const stats = await Partial.getData("BTCUSDT", "my-strategy");
- * const report = await Partial.getReport("BTCUSDT", "my-strategy");
- * await Partial.dump("BTCUSDT", "my-strategy");
- * ```
+ * Global singleton instance of HighestProfitUtils.
  */
-declare const Partial$1: PartialUtils;
+declare const HighestProfit: HighestProfitUtils;
 
 /**
  * Utility class containing predefined trading constants for take-profit and stop-loss levels.
@@ -19778,6 +20475,12 @@ declare const strategyCommitSubject: Subject<StrategyCommitContract>;
  * BacktestLogicPrivateService::*run
  */
 declare const backtestScheduleOpenSubject: Subject<IStrategyTickResultOpened>;
+/**
+ * Highest profit emitter for real-time profit tracking.
+ * Emits updates on the highest profit achieved for an open position.
+ * Allows users to track profit milestones and implement custom management logic based on profit levels.
+ */
+declare const highestProfitSubject: Subject<HighestProfitContract>;
 
 declare const emitters_activePingSubject: typeof activePingSubject;
 declare const emitters_backtestScheduleOpenSubject: typeof backtestScheduleOpenSubject;
@@ -19787,6 +20490,7 @@ declare const emitters_doneLiveSubject: typeof doneLiveSubject;
 declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
 declare const emitters_errorEmitter: typeof errorEmitter;
 declare const emitters_exitEmitter: typeof exitEmitter;
+declare const emitters_highestProfitSubject: typeof highestProfitSubject;
 declare const emitters_partialLossSubject: typeof partialLossSubject;
 declare const emitters_partialProfitSubject: typeof partialProfitSubject;
 declare const emitters_performanceEmitter: typeof performanceEmitter;
@@ -19805,7 +20509,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_activePingSubject as activePingSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, 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_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, 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_highestProfitSubject as highestProfitSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -19970,7 +20674,7 @@ declare const investedCostToPercent: (dollarAmount: number, investedCost: number
  *
  * @param newStopLossPrice - Desired absolute stop-loss price
  * @param originalStopLossPrice - Original stop-loss price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @returns percentShift to pass to `commitTrailingStop`
  *
  * @example
@@ -19988,7 +20692,7 @@ declare const slPriceToPercentShift: (newStopLossPrice: number, originalStopLoss
  *
  * @param newTakeProfitPrice - Desired absolute take-profit price
  * @param originalTakeProfitPrice - Original take-profit price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @returns percentShift to pass to `commitTrailingTake`
  *
  * @example
@@ -20009,7 +20713,7 @@ declare const tpPriceToPercentShift: (newTakeProfitPrice: number, originalTakePr
  *
  * @param percentShift - Value returned by `slPriceToPercentShift` (or passed to `commitTrailingStop`)
  * @param originalStopLossPrice - Original stop-loss price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @param position - Position direction: "long" or "short"
  * @returns Absolute stop-loss price corresponding to the given percentShift
  *
@@ -20030,7 +20734,7 @@ declare const slPercentShiftToPrice: (percentShift: number, originalStopLossPric
  *
  * @param percentShift - Value returned by `tpPriceToPercentShift` (or passed to `commitTrailingTake`)
  * @param originalTakeProfitPrice - Original take-profit price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @param position - Position direction: "long" or "short"
  * @returns Absolute take-profit price corresponding to the given percentShift
  *
@@ -21330,7 +22034,7 @@ declare class StrategyConnectionService implements TStrategy$1 {
      * @param context - Execution context with strategyName, exchangeName, frameName
      * @returns Promise resolving to effective entry price or null
      */
-    getPositionAveragePrice: (backtest: boolean, symbol: string, context: {
+    getPositionEffectivePrice: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -21619,6 +22323,136 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Delegates to ClientStrategy.getPositionEstimateMinutes().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to estimated duration in minutes or null
+     */
+    getPositionEstimateMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionCountdownMinutes().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to remaining minutes (≥ 0) or null
+     */
+    getPositionCountdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestProfitPrice().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to price or null
+     */
+    getPositionHighestProfitPrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestProfitTimestamp().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionHighestProfitTimestamp: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestPnlPercentage().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionHighestPnlPercentage: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestPnlCost().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionHighestPnlCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     *
+     * Delegates to ClientStrategy.getPositionHighestProfitBreakeven().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+     */
+    getPositionHighestProfitBreakeven: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionDrawdownMinutes().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to drawdown duration in minutes or null
+     */
+    getPositionDrawdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
     /**
      * Disposes the ClientStrategy instance for the given context.
      *
@@ -22694,7 +23528,7 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
-    getPositionAveragePrice: (backtest: boolean, symbol: string, context: {
+    getPositionEffectivePrice: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -23243,6 +24077,119 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to estimated duration in minutes or null
+     */
+    getPositionEstimateMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to remaining minutes (≥ 0) or null
+     */
+    getPositionCountdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to price or null
+     */
+    getPositionHighestProfitPrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionHighestProfitTimestamp: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionHighestPnlPercentage: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionHighestPnlCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+     */
+    getPositionHighestProfitBreakeven: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to drawdown duration in minutes or null
+     */
+    getPositionDrawdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
 }
 
 /**
@@ -25717,6 +26664,19 @@ declare class SyncReportService {
     unsubscribe: () => Promise<void>;
 }
 
+/**
+ * Service for logging highest profit events to the JSONL report database.
+ *
+ * Listens to highestProfitSubject and writes each new price record to
+ * Report.writeData() for persistence and analytics.
+ */
+declare class HighestProfitReportService {
+    private readonly loggerService;
+    private tick;
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    unsubscribe: () => Promise<void>;
+}
+
 declare const backtest: {
     exchangeValidationService: ExchangeValidationService;
     strategyValidationService: StrategyValidationService;
@@ -25738,6 +26698,7 @@ declare const backtest: {
     riskReportService: RiskReportService;
     strategyReportService: StrategyReportService;
     syncReportService: SyncReportService;
+    highestProfitReportService: HighestProfitReportService;
     backtestMarkdownService: BacktestMarkdownService;
     liveMarkdownService: LiveMarkdownService;
     scheduleMarkdownService: ScheduleMarkdownService;
@@ -25749,6 +26710,7 @@ declare const backtest: {
     riskMarkdownService: RiskMarkdownService;
     strategyMarkdownService: StrategyMarkdownService;
     syncMarkdownService: SyncMarkdownService;
+    highestProfitMarkdownService: HighestProfitMarkdownService;
     backtestLogicPublicService: BacktestLogicPublicService;
     liveLogicPublicService: LiveLogicPublicService;
     walkerLogicPublicService: WalkerLogicPublicService;
@@ -25868,4 +26830,4 @@ declare const getTotalClosed: (signal: Signal) => {
     remainingCostBasis: number;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionEntryOverlap, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };