backtest-kit 2.2.1 → 2.2.5

package/types.d.ts

@@ -1257,6 +1257,8 @@ interface IStrategyTickResultIdle {
     currentPrice: number;
     /** Whether this event is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Tick result: scheduled signal created, waiting for price to reach entry point.
@@ -1279,6 +1281,8 @@ interface IStrategyTickResultScheduled {
     currentPrice: number;
     /** Whether this event is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Tick result: scheduled signal is waiting for price to reach entry point.
@@ -1308,6 +1312,8 @@ interface IStrategyTickResultWaiting {
     pnl: IStrategyPnL;
     /** Whether this event is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Tick result: new signal just created.
@@ -1330,6 +1336,8 @@ interface IStrategyTickResultOpened {
     currentPrice: number;
     /** Whether this event is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Tick result: signal is being monitored.
@@ -1358,6 +1366,8 @@ interface IStrategyTickResultActive {
     pnl: IStrategyPnL;
     /** Whether this event is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Tick result: signal closed with PNL.
@@ -1388,6 +1398,8 @@ interface IStrategyTickResultClosed {
     backtest: boolean;
     /** Close ID (only for user-initiated closes with reason "closed") */
     closeId?: string;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Tick result: scheduled signal cancelled without opening position.
@@ -1416,6 +1428,8 @@ interface IStrategyTickResultCancelled {
     reason: StrategyCancelReason;
     /** Optional cancellation ID (provided when user calls Backtest.cancel() or Live.cancel()) */
     cancelId?: string;
+    /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Discriminated union of all tick results.
@@ -3839,6 +3853,8 @@ declare const COLUMN_CONFIG: {
     risk_columns: ColumnModel<RiskEvent>[];
     /** Columns for scheduled report output */
     schedule_columns: ColumnModel<ScheduledEvent>[];
+    /** Columns for strategy management events */
+    strategy_columns: ColumnModel<StrategyEvent>[];
     /** Walker: PnL summary columns */
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     /** Walker: strategy-level summary columns */
@@ -3997,6 +4013,7 @@ declare function getColumns(): {
     performance_columns: ColumnModel<MetricStats>[];
     risk_columns: ColumnModel<RiskEvent>[];
     schedule_columns: ColumnModel<ScheduledEvent>[];
+    strategy_columns: ColumnModel<StrategyEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 };
@@ -4023,6 +4040,7 @@ declare function getDefaultColumns(): Readonly<{
     performance_columns: ColumnModel<MetricStats>[];
     risk_columns: ColumnModel<RiskEvent>[];
     schedule_columns: ColumnModel<ScheduledEvent>[];
+    strategy_columns: ColumnModel<StrategyEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 }>;
@@ -5071,6 +5089,84 @@ interface WalkerContract {
     totalStrategies: number;
 }
 
+/**
+ * Base fields for all signal commit events.
+ */
+interface SignalCommitBase {
+    symbol: string;
+    strategyName: StrategyName;
+    exchangeName: ExchangeName;
+    frameName: FrameName;
+    backtest: boolean;
+}
+/**
+ * Cancel scheduled signal event.
+ */
+interface CancelScheduledCommit extends SignalCommitBase {
+    action: "cancel-scheduled";
+    cancelId?: string;
+}
+/**
+ * Close pending signal event.
+ */
+interface ClosePendingCommit extends SignalCommitBase {
+    action: "close-pending";
+    closeId?: string;
+}
+/**
+ * Partial profit event.
+ */
+interface PartialProfitCommit extends SignalCommitBase {
+    action: "partial-profit";
+    percentToClose: number;
+    currentPrice: number;
+}
+/**
+ * Partial loss event.
+ */
+interface PartialLossCommit extends SignalCommitBase {
+    action: "partial-loss";
+    percentToClose: number;
+    currentPrice: number;
+}
+/**
+ * Trailing stop event.
+ */
+interface TrailingStopCommit extends SignalCommitBase {
+    action: "trailing-stop";
+    percentShift: number;
+    currentPrice: number;
+}
+/**
+ * Trailing take event.
+ */
+interface TrailingTakeCommit extends SignalCommitBase {
+    action: "trailing-take";
+    percentShift: number;
+    currentPrice: number;
+}
+/**
+ * Breakeven event.
+ */
+interface BreakevenCommit extends SignalCommitBase {
+    action: "breakeven";
+    currentPrice: number;
+}
+/**
+ * Discriminated union for strategy management signal events.
+ *
+ * Emitted by strategyCommitSubject when strategy management actions are executed.
+ *
+ * Consumers:
+ * - StrategyReportService: Persists events to JSON files
+ * - StrategyMarkdownService: Accumulates events for markdown reports
+ *
+ * Note: Signal data (IPublicSignalRow) is NOT included in this contract.
+ * Consumers must retrieve signal data from StrategyCoreService using
+ * getPendingSignal() or getScheduledSignal() methods.
+ */
+type StrategyCommitContract = CancelScheduledCommit | ClosePendingCommit | PartialProfitCommit | PartialLossCommit | TrailingStopCommit | TrailingTakeCommit | BreakevenCommit;
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -6001,6 +6097,72 @@ declare function listenActivePing(fn: (event: ActivePingContract) => void): () =
  * ```
  */
 declare function listenActivePingOnce(filterFn: (event: ActivePingContract) => boolean, fn: (event: ActivePingContract) => void): () => void;
+/**
+ * Subscribes to strategy management events with queued async processing.
+ *
+ * Emits when strategy management actions are executed:
+ * - cancel-scheduled: Scheduled signal cancelled
+ * - close-pending: Pending signal closed
+ * - partial-profit: Partial close at profit level
+ * - partial-loss: Partial close at loss level
+ * - trailing-stop: Stop-loss adjusted
+ * - trailing-take: Take-profit adjusted
+ * - breakeven: Stop-loss moved to entry price
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle strategy commit events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenStrategyCommit } from "./function/event";
+ *
+ * const unsubscribe = listenStrategyCommit((event) => {
+ *   console.log(`[${event.action}] ${event.symbol}`);
+ *   console.log(`Strategy: ${event.strategyName}, Exchange: ${event.exchangeName}`);
+ *   if (event.action === "partial-profit") {
+ *     console.log(`Closed ${event.percentToClose}% at ${event.currentPrice}`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenStrategyCommit(fn: (event: StrategyCommitContract) => void): () => void;
+/**
+ * Subscribes to filtered strategy management events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific strategy actions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenStrategyCommitOnce } from "./function/event";
+ *
+ * // Wait for first trailing stop adjustment
+ * listenStrategyCommitOnce(
+ *   (event) => event.action === "trailing-stop",
+ *   (event) => console.log("Trailing stop adjusted:", event.symbol)
+ * );
+ *
+ * // Wait for breakeven on BTCUSDT
+ * const cancel = listenStrategyCommitOnce(
+ *   (event) => event.action === "breakeven" && event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT moved to breakeven at", event.currentPrice)
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+declare function listenStrategyCommitOnce(filterFn: (event: StrategyCommitContract) => boolean, fn: (event: StrategyCommitContract) => void): () => void;
 
 /**
  * Checks if trade context is active (execution and method contexts).
@@ -6288,93 +6450,307 @@ interface ColumnModel<T extends object = any> {
  * Emitted when a new trading position is opened.
  */
 interface SignalOpenedNotification {
+    /** Discriminator for type-safe union */
     type: "signal.opened";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when signal was opened (pendingAt) */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that generated this signal */
     strategyName: StrategyName;
+    /** Exchange name where signal was executed */
     exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
     signalId: string;
+    /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
+    /** Entry price for the position */
     priceOpen: number;
+    /** Take profit target price */
     priceTakeProfit: number;
+    /** Stop loss exit price */
     priceStopLoss: number;
+    /** Optional human-readable description of signal reason */
     note?: string;
+    /** Unix timestamp in milliseconds when the tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Signal closed notification.
  * Emitted when a trading position is closed (TP/SL hit).
  */
 interface SignalClosedNotification {
+    /** Discriminator for type-safe union */
     type: "signal.closed";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when signal was closed (closeTimestamp) */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that generated this signal */
     strategyName: StrategyName;
+    /** Exchange name where signal was executed */
     exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
     signalId: string;
+    /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
+    /** Entry price for the position */
     priceOpen: number;
+    /** Exit price when position was closed */
     priceClose: number;
+    /** Profit/loss as percentage (e.g., 1.5 for +1.5%, -2.3 for -2.3%) */
     pnlPercentage: number;
+    /** Why signal closed (time_expired | take_profit | stop_loss | closed) */
     closeReason: string;
+    /** Duration of position in minutes (from pendingAt to closeTimestamp) */
     duration: number;
+    /** Optional human-readable description of signal reason */
     note?: string;
+    /** Unix timestamp in milliseconds when the tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Partial profit notification.
  * Emitted when signal reaches profit level milestone (10%, 20%, etc).
  */
-interface PartialProfitNotification {
-    type: "partial.profit";
+interface PartialProfitAvailableNotification {
+    /** Discriminator for type-safe union */
+    type: "partial_profit.available";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when partial profit level was reached */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that generated this signal */
     strategyName: StrategyName;
+    /** Exchange name where signal was executed */
     exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
     signalId: string;
+    /** Profit level milestone reached (10, 20, 30, etc) */
     level: PartialLevel;
+    /** Current market price when milestone was reached */
     currentPrice: number;
+    /** Entry price for the position */
     priceOpen: number;
+    /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
 }
 /**
  * Partial loss notification.
  * Emitted when signal reaches loss level milestone (-10%, -20%, etc).
  */
-interface PartialLossNotification {
-    type: "partial.loss";
+interface PartialLossAvailableNotification {
+    /** Discriminator for type-safe union */
+    type: "partial_loss.available";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when partial loss level was reached */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that generated this signal */
     strategyName: StrategyName;
+    /** Exchange name where signal was executed */
     exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
     signalId: string;
+    /** Loss level milestone reached (10, 20, 30, etc) */
     level: PartialLevel;
+    /** Current market price when milestone was reached */
+    currentPrice: number;
+    /** Entry price for the position */
+    priceOpen: number;
+    /** Trade direction: "long" (buy) or "short" (sell) */
+    position: "long" | "short";
+}
+/**
+ * Breakeven available notification.
+ * Emitted when signal's stop-loss can be moved to breakeven (entry price).
+ */
+interface BreakevenAvailableNotification {
+    /** Discriminator for type-safe union */
+    type: "breakeven.available";
+    /** Unique notification identifier */
+    id: string;
+    /** Unix timestamp in milliseconds when breakeven became available */
+    timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
+    backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name that generated this signal */
+    strategyName: StrategyName;
+    /** Exchange name where signal was executed */
+    exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
+    signalId: string;
+    /** Current market price when breakeven became available */
     currentPrice: number;
+    /** Entry price for the position (breakeven level) */
     priceOpen: number;
+    /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
 }
+/**
+ * Partial profit commit notification.
+ * Emitted when partial profit action is executed.
+ */
+interface PartialProfitCommitNotification {
+    /** Discriminator for type-safe union */
+    type: "partial_profit.commit";
+    /** Unique notification identifier */
+    id: string;
+    /** Unix timestamp in milliseconds when partial profit was committed */
+    timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
+    backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name that generated this signal */
+    strategyName: StrategyName;
+    /** Exchange name where signal was executed */
+    exchangeName: ExchangeName;
+    /** Percentage of position closed (0-100) */
+    percentToClose: number;
+    /** Current market price when partial was executed */
+    currentPrice: number;
+}
+/**
+ * Partial loss commit notification.
+ * Emitted when partial loss action is executed.
+ */
+interface PartialLossCommitNotification {
+    /** Discriminator for type-safe union */
+    type: "partial_loss.commit";
+    /** Unique notification identifier */
+    id: string;
+    /** Unix timestamp in milliseconds when partial loss was committed */
+    timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
+    backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name that generated this signal */
+    strategyName: StrategyName;
+    /** Exchange name where signal was executed */
+    exchangeName: ExchangeName;
+    /** Percentage of position closed (0-100) */
+    percentToClose: number;
+    /** Current market price when partial was executed */
+    currentPrice: number;
+}
+/**
+ * Breakeven commit notification.
+ * Emitted when breakeven action is executed.
+ */
+interface BreakevenCommitNotification {
+    /** Discriminator for type-safe union */
+    type: "breakeven.commit";
+    /** Unique notification identifier */
+    id: string;
+    /** Unix timestamp in milliseconds when breakeven was committed */
+    timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
+    backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name that generated this signal */
+    strategyName: StrategyName;
+    /** Exchange name where signal was executed */
+    exchangeName: ExchangeName;
+    /** Current market price when breakeven was executed */
+    currentPrice: number;
+}
+/**
+ * Trailing stop commit notification.
+ * Emitted when trailing stop action is executed.
+ */
+interface TrailingStopCommitNotification {
+    /** Discriminator for type-safe union */
+    type: "trailing_stop.commit";
+    /** Unique notification identifier */
+    id: string;
+    /** Unix timestamp in milliseconds when trailing stop was committed */
+    timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
+    backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name that generated this signal */
+    strategyName: StrategyName;
+    /** Exchange name where signal was executed */
+    exchangeName: ExchangeName;
+    /** Percentage shift of original SL distance (-100 to 100) */
+    percentShift: number;
+    /** Current market price when trailing stop was executed */
+    currentPrice: number;
+}
+/**
+ * Trailing take commit notification.
+ * Emitted when trailing take action is executed.
+ */
+interface TrailingTakeCommitNotification {
+    /** Discriminator for type-safe union */
+    type: "trailing_take.commit";
+    /** Unique notification identifier */
+    id: string;
+    /** Unix timestamp in milliseconds when trailing take was committed */
+    timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
+    backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name that generated this signal */
+    strategyName: StrategyName;
+    /** Exchange name where signal was executed */
+    exchangeName: ExchangeName;
+    /** Percentage shift of original TP distance (-100 to 100) */
+    percentShift: number;
+    /** Current market price when trailing take was executed */
+    currentPrice: number;
+}
 /**
  * Risk rejection notification.
  * Emitted when a signal is rejected due to risk management rules.
  */
 interface RiskRejectionNotification {
+    /** Discriminator for type-safe union */
     type: "risk.rejection";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when signal was rejected */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that attempted to create signal */
     strategyName: StrategyName;
+    /** Exchange name where signal was rejected */
     exchangeName: ExchangeName;
+    /** Human-readable reason for rejection */
     rejectionNote: string;
+    /** Optional unique rejection identifier for tracking */
     rejectionId: string | null;
+    /** Number of currently active positions at rejection time */
     activePositionCount: number;
+    /** Current market price when rejection occurred */
     currentPrice: number;
+    /** The signal that was rejected */
     pendingSignal: ISignalDto;
 }
 /**
@@ -6382,73 +6758,81 @@ interface RiskRejectionNotification {
  * Emitted when a signal is scheduled for future execution.
  */
 interface SignalScheduledNotification {
+    /** Discriminator for type-safe union */
     type: "signal.scheduled";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when signal was scheduled (scheduledAt) */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that generated this signal */
     strategyName: StrategyName;
+    /** Exchange name where signal will be executed */
     exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
     signalId: string;
+    /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
+    /** Target entry price for activation */
     priceOpen: number;
+    /** Unix timestamp in milliseconds when signal was scheduled */
     scheduledAt: number;
+    /** Current market price when signal was scheduled */
     currentPrice: number;
+    /** Unix timestamp in milliseconds when the tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Signal cancelled notification.
  * Emitted when a scheduled signal is cancelled before activation.
  */
 interface SignalCancelledNotification {
+    /** Discriminator for type-safe union */
     type: "signal.cancelled";
+    /** Unique notification identifier */
     id: string;
+    /** Unix timestamp in milliseconds when signal was cancelled (closeTimestamp) */
     timestamp: number;
+    /** Whether this notification is from backtest mode (true) or live mode (false) */
     backtest: boolean;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Strategy name that generated this signal */
     strategyName: StrategyName;
+    /** Exchange name where signal was scheduled */
     exchangeName: ExchangeName;
+    /** Unique signal identifier (UUID v4) */
     signalId: string;
+    /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
+    /** Why signal was cancelled (timeout | price_reject | user) */
     cancelReason: string;
+    /** Optional cancellation identifier (provided when user calls cancel()) */
     cancelId: string;
+    /** Duration in minutes from scheduledAt to cancellation */
     duration: number;
-}
-/**
- * Backtest completed notification.
- * Emitted when backtest execution completes.
- */
-interface BacktestDoneNotification {
-    type: "backtest.done";
-    id: string;
-    timestamp: number;
-    backtest: true;
-    symbol: string;
-    strategyName: StrategyName;
-    exchangeName: ExchangeName;
-}
-/**
- * Live trading completed notification.
- * Emitted when live trading execution completes.
- */
-interface LiveDoneNotification {
-    type: "live.done";
-    id: string;
-    timestamp: number;
-    backtest: false;
-    symbol: string;
-    strategyName: StrategyName;
-    exchangeName: ExchangeName;
+    /** Unix timestamp in milliseconds when the tick result was created (from candle timestamp in backtest or execution context when in live) */
+    createdAt: number;
 }
 /**
  * Error notification.
  * Emitted for recoverable errors in background tasks.
  */
 interface InfoErrorNotification {
+    /** Discriminator for type-safe union */
     type: "error.info";
+    /** Unique notification identifier */
     id: string;
+    /** Serialized error object with stack trace and metadata */
     error: object;
+    /** Human-readable error message */
     message: string;
+    /** Unix timestamp in milliseconds when error occurred */
     timestamp: number;
+    /** Always false for error notifications (errors are from live context) */
     backtest: boolean;
 }
 /**
@@ -6456,11 +6840,17 @@ interface InfoErrorNotification {
  * Emitted for fatal errors requiring process termination.
  */
 interface CriticalErrorNotification {
+    /** Discriminator for type-safe union */
     type: "error.critical";
+    /** Unique notification identifier */
     id: string;
+    /** Serialized error object with stack trace and metadata */
     error: object;
+    /** Human-readable error message */
     message: string;
+    /** Unix timestamp in milliseconds when critical error occurred */
     timestamp: number;
+    /** Always false for error notifications (errors are from live context) */
     backtest: boolean;
 }
 /**
@@ -6468,29 +6858,19 @@ interface CriticalErrorNotification {
  * Emitted when risk validation functions throw errors.
  */
 interface ValidationErrorNotification {
+    /** Discriminator for type-safe union */
     type: "error.validation";
+    /** Unique notification identifier */
     id: string;
+    /** Serialized error object with stack trace and metadata */
     error: object;
+    /** Human-readable validation error message */
     message: string;
+    /** Unix timestamp in milliseconds when validation error occurred */
     timestamp: number;
+    /** Always false for error notifications (errors are from live context) */
     backtest: boolean;
 }
-/**
- * Progress update notification.
- * Emitted during backtest execution.
- */
-interface ProgressBacktestNotification {
-    type: "progress.backtest";
-    id: string;
-    timestamp: number;
-    backtest: true;
-    exchangeName: ExchangeName;
-    strategyName: StrategyName;
-    symbol: string;
-    totalFrames: number;
-    processedFrames: number;
-    progress: number;
-}
 /**
  * Root discriminated union of all notification types.
  * Type discrimination is done via the `type` field.
@@ -6517,7 +6897,7 @@ interface ProgressBacktestNotification {
  * }
  * ```
  */
-type NotificationModel = SignalOpenedNotification | SignalClosedNotification | PartialProfitNotification | PartialLossNotification | RiskRejectionNotification | SignalScheduledNotification | SignalCancelledNotification | BacktestDoneNotification | LiveDoneNotification | InfoErrorNotification | CriticalErrorNotification | ValidationErrorNotification | ProgressBacktestNotification;
+type NotificationModel = SignalOpenedNotification | SignalClosedNotification | PartialProfitAvailableNotification | PartialLossAvailableNotification | BreakevenAvailableNotification | PartialProfitCommitNotification | PartialLossCommitNotification | BreakevenCommitNotification | TrailingStopCommitNotification | TrailingTakeCommitNotification | RiskRejectionNotification | SignalScheduledNotification | SignalCancelledNotification | InfoErrorNotification | CriticalErrorNotification | ValidationErrorNotification;
 
 /**
  * Unified tick event data for report generation.
@@ -6923,6 +7303,79 @@ interface RiskStatisticsModel {
     byStrategy: Record<string, number>;
 }
 
+/**
+ * Action types for strategy events.
+ * Represents all possible strategy management actions.
+ */
+type StrategyActionType = "cancel-scheduled" | "close-pending" | "partial-profit" | "partial-loss" | "trailing-stop" | "trailing-take" | "breakeven";
+/**
+ * Unified strategy event data for markdown report generation.
+ * Contains all information about strategy management actions.
+ */
+interface StrategyEvent {
+    /** Event timestamp in milliseconds */
+    timestamp: number;
+    /** Trading pair symbol */
+    symbol: string;
+    /** Strategy name */
+    strategyName: StrategyName;
+    /** Exchange name */
+    exchangeName: ExchangeName;
+    /** Frame name (empty for live) */
+    frameName: FrameName;
+    /** Signal ID */
+    signalId: string;
+    /** Action type */
+    action: StrategyActionType;
+    /** Current market price when action was executed */
+    currentPrice?: number;
+    /** Percent to close for partial profit/loss */
+    percentToClose?: number;
+    /** Percent shift for trailing stop/take */
+    percentShift?: number;
+    /** Cancel ID for cancel-scheduled action */
+    cancelId?: string;
+    /** Close ID for close-pending action */
+    closeId?: string;
+    /** ISO timestamp string when action was created */
+    createdAt: string;
+    /** True if backtest mode, false if live mode */
+    backtest: boolean;
+}
+/**
+ * Statistical data calculated from strategy events.
+ *
+ * Provides metrics for strategy action tracking.
+ *
+ * @example
+ * ```typescript
+ * const stats = await Strategy.getData("BTCUSDT", "my-strategy");
+ *
+ * console.log(`Total events: ${stats.totalEvents}`);
+ * console.log(`Cancel scheduled: ${stats.cancelScheduledCount}`);
+ * ```
+ */
+interface StrategyStatisticsModel {
+    /** Array of all strategy events with full details */
+    eventList: StrategyEvent[];
+    /** Total number of strategy events */
+    totalEvents: number;
+    /** Count of cancel-scheduled events */
+    cancelScheduledCount: number;
+    /** Count of close-pending events */
+    closePendingCount: number;
+    /** Count of partial-profit events */
+    partialProfitCount: number;
+    /** Count of partial-loss events */
+    partialLossCount: number;
+    /** Count of trailing-stop events */
+    trailingStopCount: number;
+    /** Count of trailing-take events */
+    trailingTakeCount: number;
+    /** Count of breakeven events */
+    breakevenCount: number;
+}
+
 declare const BASE_WAIT_FOR_INIT_SYMBOL: unique symbol;
 /**
  * Signal data stored in persistence layer.
@@ -7602,6 +8055,8 @@ declare const WRITE_SAFE_SYMBOL$1: unique symbol;
  * Controls which report services should be activated for JSONL event logging.
  */
 interface IReportTarget {
+    /** Enable strategy commit actions */
+    strategy: boolean;
     /** Enable risk rejection event logging */
     risk: boolean;
     /** Enable breakeven event logging */
@@ -7771,7 +8226,7 @@ declare class ReportUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, }?: Partial<IReportTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, }?: Partial<IReportTarget>) => (...args: any[]) => any;
     /**
      * Disables report services selectively.
      *
@@ -7808,7 +8263,7 @@ declare class ReportUtils {
      * Report.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, }?: Partial<IReportTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, }?: Partial<IReportTarget>) => void;
 }
 /**
  * Report adapter with pluggable storage backend and instance memoization.
@@ -7878,6 +8333,8 @@ declare const Report: ReportAdapter;
  * Controls which markdown report services should be activated.
  */
 interface IMarkdownTarget {
+    /** Enable strategy event tracking reports (entry/exit signals) */
+    strategy: boolean;
     /** Enable risk rejection tracking reports (signals blocked by risk limits) */
     risk: boolean;
     /** Enable breakeven event tracking reports (when stop loss moves to entry) */
@@ -8091,7 +8548,7 @@ declare class MarkdownUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
     /**
      * Disables markdown report services selectively.
      *
@@ -8129,7 +8586,7 @@ declare class MarkdownUtils {
      * Markdown.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, }?: Partial<IMarkdownTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, }?: Partial<IMarkdownTarget>) => void;
 }
 /**
  * Markdown adapter with pluggable storage backend and instance memoization.
@@ -8231,7 +8688,7 @@ declare const Markdown: MarkdownAdapter;
  * @see ColumnModel for the base interface
  * @see IStrategyTickResultClosed for the signal data structure
  */
-type Columns$7 = ColumnModel<IStrategyTickResultClosed>;
+type Columns$8 = ColumnModel<IStrategyTickResultClosed>;
 /**
  * Service for generating and saving backtest markdown reports.
  *
@@ -8325,7 +8782,7 @@ declare class BacktestMarkdownService {
      * 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.
@@ -8350,7 +8807,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$7[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
     /**
      * Clears accumulated signal data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -8860,7 +9317,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, columns?: Columns$7[]) => Promise<string>;
+    }, columns?: Columns$8[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -8891,7 +9348,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, path?: string, columns?: Columns$7[]) => Promise<void>;
+    }, path?: string, columns?: Columns$8[]) => Promise<void>;
     /**
      * Lists all active backtest instances with their current status.
      *
@@ -8965,7 +9422,7 @@ declare const Backtest: BacktestUtils;
  * @see ColumnModel for the base interface
  * @see TickEvent for the event data structure
  */
-type Columns$6 = ColumnModel<TickEvent>;
+type Columns$7 = ColumnModel<TickEvent>;
 /**
  * Service for generating and saving live trading markdown reports.
  *
@@ -9092,7 +9549,7 @@ declare class LiveMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -9117,7 +9574,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$6[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -9586,7 +10043,7 @@ declare class LiveUtils {
     getReport: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, columns?: Columns$6[]) => Promise<string>;
+    }, columns?: Columns$7[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -9616,7 +10073,7 @@ declare class LiveUtils {
     dump: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, path?: string, columns?: Columns$6[]) => Promise<void>;
+    }, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Lists all active live trading instances with their current status.
      *
@@ -9686,7 +10143,7 @@ declare const Live: LiveUtils;
  * @see ColumnModel for the base interface
  * @see ScheduledEvent for the event data structure
  */
-type Columns$5 = ColumnModel<ScheduledEvent>;
+type Columns$6 = ColumnModel<ScheduledEvent>;
 /**
  * Service for generating and saving scheduled signals markdown reports.
  *
@@ -9797,7 +10254,7 @@ declare class ScheduleMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -9822,7 +10279,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$5[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -9912,7 +10369,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -9934,7 +10391,7 @@ declare class ScheduleUtils {
         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 ScheduleUtils for convenient scheduled signals reporting.
@@ -9980,7 +10437,7 @@ declare const Schedule: ScheduleUtils;
  * @see ColumnModel for the base interface
  * @see MetricStats for the metric data structure
  */
-type Columns$4 = ColumnModel<MetricStats>;
+type Columns$5 = ColumnModel<MetricStats>;
 /**
  * Service for collecting and analyzing performance metrics.
  *
@@ -10087,7 +10544,7 @@ declare class PerformanceMarkdownService {
      * 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 performance report to disk.
      *
@@ -10108,7 +10565,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$4[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
     /**
      * Clears accumulated performance data from storage.
      *
@@ -10216,7 +10673,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$4[]): Promise<string>;
+    }, backtest?: boolean, columns?: Columns$5[]): Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -10241,7 +10698,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$4[]): Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$5[]): Promise<void>;
 }
 
 /**
@@ -10672,7 +11129,7 @@ declare const Walker: WalkerUtils;
  * @see ColumnModel for the base interface
  * @see IHeatmapRow for the row data structure
  */
-type Columns$3 = ColumnModel<IHeatmapRow>;
+type Columns$4 = ColumnModel<IHeatmapRow>;
 /**
  * Portfolio Heatmap Markdown Service.
  *
@@ -10793,7 +11250,7 @@ declare class HeatMarkdownService {
      * // ...
      * ```
      */
-    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$3[]) => Promise<string>;
+    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
     /**
      * Saves heatmap report to disk.
      *
@@ -10818,7 +11275,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$3[]) => Promise<void>;
+    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
     /**
      * Clears accumulated heatmap data from storage.
      * If payload is provided, clears only that exchangeName+frameName+backtest combination's data.
@@ -10948,7 +11405,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$3[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$4[]) => Promise<string>;
     /**
      * Saves heatmap report to disk for a strategy.
      *
@@ -10981,7 +11438,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$3[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
 }
 /**
  * Singleton instance of HeatUtils for convenient heatmap operations.
@@ -11135,7 +11592,7 @@ declare const PositionSize: typeof PositionSizeUtils;
  * @see ColumnModel for the base interface
  * @see PartialEvent for the event data structure
  */
-type Columns$2 = ColumnModel<PartialEvent>;
+type Columns$3 = ColumnModel<PartialEvent>;
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -11257,7 +11714,7 @@ declare class PartialMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$2[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$3[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -11282,7 +11739,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$2[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$3[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -11418,7 +11875,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$2[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$3[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -11455,7 +11912,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$3[]) => Promise<void>;
 }
 /**
  * Global singleton instance of PartialUtils.
@@ -11583,7 +12040,7 @@ declare const Constant: ConstantUtils;
  * @see ColumnModel for the base interface
  * @see RiskEvent for the event data structure
  */
-type Columns$1 = ColumnModel<RiskEvent>;
+type Columns$2 = ColumnModel<RiskEvent>;
 /**
  * Service for generating and saving risk rejection markdown reports.
  *
@@ -11692,7 +12149,7 @@ declare class RiskMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$1[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$2[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -11717,7 +12174,7 @@ declare class RiskMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -11855,7 +12312,7 @@ declare class RiskUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$1[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$2[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -11892,7 +12349,7 @@ declare class RiskUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
 }
 /**
  * Global singleton instance of RiskUtils.
@@ -12321,7 +12778,7 @@ declare const Notification: NotificationUtils;
  * @see ColumnModel for the base interface
  * @see BreakevenEvent for the event data structure
  */
-type Columns = ColumnModel<BreakevenEvent>;
+type Columns$1 = ColumnModel<BreakevenEvent>;
 /**
  * Service for generating and saving breakeven markdown reports.
  *
@@ -12430,7 +12887,7 @@ declare class BreakevenMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$1[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -12455,7 +12912,7 @@ declare class BreakevenMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -12583,7 +13040,7 @@ declare class BreakevenUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$1[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -12620,7 +13077,7 @@ declare class BreakevenUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$1[]) => Promise<void>;
 }
 /**
  * Global singleton instance of BreakevenUtils.
@@ -12639,169 +13096,1060 @@ declare class BreakevenUtils {
 declare const Breakeven: BreakevenUtils;
 
 /**
- * Proxy wrapper for user-defined action handlers with automatic error capture.
- *
- * Wraps all IPublicAction methods with trycatch to prevent user code errors from crashing the system.
- * All errors are logged, sent to errorEmitter, and returned as null (non-breaking).
- *
- * Key features:
- * - Automatic error catching and logging for all action methods
- * - Safe execution of partial user implementations (missing methods return null)
- * - Consistent error capture across all action lifecycle events
- * - Non-breaking failure mode (errors logged but execution continues)
- *
- * Architecture:
- * - Private constructor enforces factory pattern via fromInstance()
- * - Each method checks if target implements the method before calling
- * - Errors caught with fallback handler (warn log + errorEmitter)
- * - Returns null on error to prevent undefined behavior
- *
- * Used by:
- * - ClientAction to wrap user-provided action handlers
- * - ActionCoreService to safely invoke action callbacks
- *
- * @example
- * ```typescript
- * // Create proxy from user implementation
- * const userAction = {
- *   signal: async (event) => {
- *     // User code that might throw
- *     throw new Error('User error');
- *   }
- * };
- *
- * const proxy = ActionProxy.fromInstance(userAction);
- *
- * // Error is caught and logged, execution continues
- * await proxy.signal(event); // Logs error, returns null
- * await proxy.dispose(); // Safe call even though not implemented
- * ```
+ * Logger service with automatic context injection.
  *
- * @example
- * ```typescript
- * // Partial implementation is safe
- * const partialAction = {
- *   init: async () => console.log('Initialized'),
- *   // Other methods not implemented
- * };
+ * Features:
+ * - Delegates to user-provided logger via setLogger()
+ * - Automatically appends method context (strategyName, exchangeName, frameName)
+ * - Automatically appends execution context (symbol, when, backtest)
+ * - Defaults to NOOP_LOGGER if no logger configured
  *
- * const proxy = ActionProxy.fromInstance(partialAction);
- * await proxy.init(); // Works
- * await proxy.signal(event); // Returns null (not implemented)
- * ```
+ * Used throughout the framework for consistent logging with context.
  */
-declare class ActionProxy implements IPublicAction {
-    readonly _target: Partial<IPublicAction>;
+declare class LoggerService implements ILogger {
+    private readonly methodContextService;
+    private readonly executionContextService;
+    private _commonLogger;
     /**
-     * Creates a new ActionProxy instance.
-     *
-     * @param _target - Partial action implementation to wrap with error capture
-     * @private Use ActionProxy.fromInstance() instead
+     * Gets current method context if available.
+     * Contains strategyName, exchangeName, frameName from MethodContextService.
      */
-    private constructor();
+    private get methodContext();
     /**
-     * Initializes the action handler with error capture.
-     *
-     * Wraps the user's init() method in trycatch to prevent initialization errors from crashing the system.
-     * If the target doesn't implement init(), this method safely returns undefined.
-     *
-     * @returns Promise resolving to user's init() result or undefined if not implemented
+     * Gets current execution context if available.
+     * Contains symbol, when, backtest from ExecutionContextService.
      */
-    init(): Promise<any>;
+    private get executionContext();
     /**
-     * Handles signal events from all modes with error capture.
-     *
-     * Wraps the user's signal() method to catch and log any errors.
-     * Called on every tick/candle when strategy is evaluated.
+     * Logs general-purpose message with automatic context injection.
      *
-     * @param event - Signal state result with action, state, signal data, and context
-     * @returns Promise resolving to user's signal() result or null on error
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
      */
-    signal(event: IStrategyTickResult): Promise<any>;
+    log: (topic: string, ...args: any[]) => Promise<void>;
     /**
-     * Handles signal events from live trading only with error capture.
-     *
-     * Wraps the user's signalLive() method to catch and log any errors.
-     * Called every tick in live mode.
+     * Logs debug-level message with automatic context injection.
      *
-     * @param event - Signal state result from live trading
-     * @returns Promise resolving to user's signalLive() result or null on error
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
      */
-    signalLive(event: IStrategyTickResult): Promise<any>;
+    debug: (topic: string, ...args: any[]) => Promise<void>;
     /**
-     * Handles signal events from backtest only with error capture.
-     *
-     * Wraps the user's signalBacktest() method to catch and log any errors.
-     * Called every candle in backtest mode.
+     * Logs info-level message with automatic context injection.
      *
-     * @param event - Signal state result from backtest
-     * @returns Promise resolving to user's signalBacktest() result or null on error
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
      */
-    signalBacktest(event: IStrategyTickResult): Promise<any>;
+    info: (topic: string, ...args: any[]) => Promise<void>;
     /**
-     * Handles breakeven events with error capture.
-     *
-     * Wraps the user's breakevenAvailable() method to catch and log any errors.
-     * Called once per signal when stop-loss is moved to entry price.
+     * Logs warning-level message with automatic context injection.
      *
-     * @param event - Breakeven milestone data with signal info, current price, timestamp
-     * @returns Promise resolving to user's breakevenAvailable() result or null on error
+     * @param topic - Log topic/category
+     * @param args - Additional log arguments
      */
-    breakevenAvailable(event: BreakevenContract): Promise<any>;
+    warn: (topic: string, ...args: any[]) => Promise<void>;
     /**
-     * Handles partial profit level events with error capture.
-     *
-     * Wraps the user's partialProfitAvailable() method to catch and log any errors.
-     * Called once per profit level per signal (10%, 20%, 30%, etc).
+     * Sets custom logger implementation.
      *
-     * @param event - Profit milestone data with signal info, level, price, timestamp
-     * @returns Promise resolving to user's partialProfitAvailable() result or null on error
+     * @param logger - Custom logger implementing ILogger interface
      */
-    partialProfitAvailable(event: PartialProfitContract): Promise<any>;
+    setLogger: (logger: ILogger) => void;
+}
+
+/**
+ * Type definition for strategy methods.
+ * Maps all keys of IStrategy to any type.
+ * Used for dynamic method routing in StrategyCoreService.
+ */
+type TStrategy$1 = {
+    [key in keyof IStrategy]: any;
+};
+/**
+ * Global service for strategy operations with execution context injection.
+ *
+ * Wraps StrategyConnectionService with ExecutionContextService to inject
+ * symbol, when, and backtest parameters into the execution context.
+ *
+ * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
+ */
+declare class StrategyCoreService implements TStrategy$1 {
+    private readonly loggerService;
+    private readonly strategyConnectionService;
+    private readonly strategySchemaService;
+    private readonly riskValidationService;
+    private readonly strategyValidationService;
+    private readonly exchangeValidationService;
+    private readonly frameValidationService;
     /**
-     * Handles partial loss level events with error capture.
-     *
-     * Wraps the user's partialLossAvailable() method to catch and log any errors.
-     * Called once per loss level per signal (-10%, -20%, -30%, etc).
+     * Validates strategy and associated risk configuration.
      *
-     * @param event - Loss milestone data with signal info, level, price, timestamp
-     * @returns Promise resolving to user's partialLossAvailable() result or null on error
+     * Memoized to avoid redundant validations for the same symbol-strategy-exchange-frame combination.
+     * Logs validation activity.
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise that resolves when validation is complete
      */
-    partialLossAvailable(event: PartialLossContract): Promise<any>;
+    private validate;
     /**
-     * Handles scheduled ping events with error capture.
-     *
-     * Wraps the user's pingScheduled() method to catch and log any errors.
-     * Called every minute while a scheduled signal is waiting for activation.
+     * Retrieves the currently active pending signal for the symbol.
+     * If no active signal exists, returns null.
+     * Used internally for monitoring TP/SL and time expiration.
      *
-     * @param event - Scheduled signal monitoring data with symbol, strategy info, signal data, timestamp
-     * @returns Promise resolving to user's pingScheduled() result or null on error
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to pending signal or null
      */
-    pingScheduled(event: SchedulePingContract): Promise<any>;
+    getPendingSignal: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<ISignalRow | null>;
     /**
-     * Handles active ping events with error capture.
-     *
-     * Wraps the user's pingActive() method to catch and log any errors.
-     * Called every minute while a pending signal is active (position open).
+     * Retrieves the currently active scheduled signal for the symbol.
+     * If no scheduled signal exists, returns null.
+     * Used internally for monitoring scheduled signal activation.
      *
-     * @param event - Active pending signal monitoring data with symbol, strategy info, signal data, timestamp
-     * @returns Promise resolving to user's pingActive() result or null on error
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to scheduled signal or null
      */
-    pingActive(event: ActivePingContract): Promise<any>;
+    getScheduledSignal: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<IScheduledSignalRow | null>;
     /**
-     * Handles risk rejection events with error capture.
+     * Checks if breakeven threshold has been reached for the current pending signal.
      *
-     * Wraps the user's riskRejection() method to catch and log any errors.
-     * Called only when signal is rejected by risk management validation.
+     * Validates strategy existence and delegates to connection service
+     * to check if price has moved far enough to cover transaction costs.
      *
-     * @param event - Risk rejection data with symbol, pending signal, rejection reason, timestamp
-     * @returns Promise resolving to user's riskRejection() result or null on error
-     */
-    riskRejection(event: RiskContract): Promise<any>;
-    /**
-     * Cleans up resources with error capture.
+     * Does not require execution context as this is a state query operation.
      *
-     * Wraps the user's dispose() method to catch and log any errors.
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check against threshold
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+     * const canBreakeven = await strategyCoreService.getBreakeven(
+     *   false,
+     *   "BTCUSDT",
+     *   100.5,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * // Returns true (price >= 100.4)
+     *
+     * if (canBreakeven) {
+     *   await strategyCoreService.breakeven(false, "BTCUSDT", 100.5, context);
+     * }
+     * ```
+     */
+    getBreakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Checks if the strategy has been stopped.
+     *
+     * Validates strategy existence and delegates to connection service
+     * to retrieve the stopped state from the strategy instance.
+     *
+     * @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 strategy is stopped, false otherwise
+     */
+    getStopped: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Checks signal status at a specific timestamp.
+     *
+     * Wraps strategy tick() with execution context containing symbol, timestamp,
+     * and backtest mode flag.
+     *
+     * @param symbol - Trading pair symbol
+     * @param when - Timestamp for tick evaluation
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Discriminated union of tick result (idle, opened, active, closed)
+     */
+    tick: (symbol: string, when: Date, backtest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<IStrategyTickResult>;
+    /**
+     * Runs fast backtest against candle array.
+     *
+     * Wraps strategy backtest() with execution context containing symbol,
+     * timestamp, and backtest mode flag.
+     *
+     * @param symbol - Trading pair symbol
+     * @param candles - Array of historical candles to test against
+     * @param when - Starting timestamp for backtest
+     * @param backtest - Whether running in backtest mode (typically true)
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Closed signal result with PNL
+     */
+    backtest: (symbol: string, candles: ICandleData[], when: Date, backtest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<IStrategyBacktestResult>;
+    /**
+     * Stops the strategy from generating new signals.
+     *
+     * Delegates to StrategyConnectionService.stop() to set internal flag.
+     * Does not require execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param ctx - Context with strategyName, exchangeName, frameName
+     * @returns Promise that resolves when stop flag is set
+     */
+    stopStrategy: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Cancels the scheduled signal without stopping the strategy.
+     *
+     * Delegates to StrategyConnectionService.cancelScheduled() to clear scheduled signal
+     * and emit cancelled event through emitters.
+     * Does not require execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param ctx - Context with strategyName, exchangeName, frameName
+     * @param cancelId - Optional cancellation ID for user-initiated cancellations
+     * @returns Promise that resolves when scheduled signal is cancelled
+     */
+    cancelScheduled: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, cancelId?: string) => Promise<void>;
+    /**
+     * Closes the pending signal without stopping the strategy.
+     *
+     * Clears the pending signal (active position).
+     * Does NOT affect scheduled signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Delegates to StrategyConnectionService.closePending() to clear pending signal
+     * and emit closed event through emitters.
+     * Does not require execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param closeId - Optional close ID for user-initiated closes
+     * @returns Promise that resolves when pending signal is closed
+     */
+    closePending: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, closeId?: string) => Promise<void>;
+    /**
+     * Disposes the ClientStrategy instance for the given context.
+     *
+     * Calls dispose on the strategy instance to clean up resources,
+     * then removes it from cache.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     */
+    dispose: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Clears the memoized ClientStrategy instance from cache.
+     *
+     * Delegates to StrategyConnectionService.dispose() if payload provided,
+     * otherwise clears all strategy instances.
+     *
+     * @param payload - Optional payload with symbol, context and backtest flag (clears all if not provided)
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+        backtest: boolean;
+    }) => Promise<void>;
+    /**
+     * Executes partial close at profit level (moving toward TP).
+     *
+     * Validates strategy existence and delegates to connection service
+     * to close a percentage of the pending position at profit.
+     *
+     * Does not require execution context as this is a direct state mutation.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to close (0-100, absolute value)
+     * @param currentPrice - Current market price for this partial close (must be in profit direction)
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if partial close executed, false if skipped
+     *
+     * @example
+     * ```typescript
+     * // Close 30% of position at profit
+     * const success = await strategyCoreService.partialProfit(
+     *   false,
+     *   "BTCUSDT",
+     *   30,
+     *   45000,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * if (success) {
+     *   console.log('Partial profit executed');
+     * }
+     * ```
+     */
+    partialProfit: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Executes partial close at loss level (moving toward SL).
+     *
+     * Validates strategy existence and delegates to connection service
+     * to close a percentage of the pending position at loss.
+     *
+     * Does not require execution context as this is a direct state mutation.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to close (0-100, absolute value)
+     * @param currentPrice - Current market price for this partial close (must be in loss direction)
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if partial close executed, false if skipped
+     *
+     * @example
+     * ```typescript
+     * // Close 40% of position at loss
+     * const success = await strategyCoreService.partialLoss(
+     *   false,
+     *   "BTCUSDT",
+     *   40,
+     *   38000,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * if (success) {
+     *   console.log('Partial loss executed');
+     * }
+     * ```
+     */
+    partialLoss: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Adjusts the trailing stop-loss distance for an active pending signal.
+     *
+     * Validates strategy existence and delegates to connection service
+     * to update the stop-loss distance by a percentage adjustment.
+     *
+     * Does not require execution context as this is a direct state mutation.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise that resolves when trailing SL is updated
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+     * // Tighten stop by 50%: newSL = 100 - 5% = 95
+     * await strategyCoreService.trailingStop(
+     *   false,
+     *   "BTCUSDT",
+     *   -50,
+     *   102,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * ```
+     */
+    trailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Adjusts the trailing take-profit distance for an active pending signal.
+     * Validates context and delegates to StrategyConnectionService.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @returns Promise that resolves when trailing TP is updated
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+     * // Move TP further by 50%: newTP = 100 + 15% = 115
+     * await strategyCoreService.trailingTake(
+     *   false,
+     *   "BTCUSDT",
+     *   50,
+     *   102,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * ```
+     */
+    trailingTake: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Moves stop-loss to breakeven when price reaches threshold.
+     * Validates context and delegates to StrategyConnectionService.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check threshold
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if breakeven was set, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const moved = await strategyCoreService.breakeven(
+     *   false,
+     *   "BTCUSDT",
+     *   112,
+     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+     * );
+     * ```
+     */
+    breakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+}
+
+/**
+ * Type alias for column configuration used in strategy markdown reports.
+ *
+ * @see ColumnModel for the base interface
+ * @see StrategyEvent for the event data structure
+ */
+type Columns = ColumnModel<StrategyEvent>;
+/**
+ * Service for accumulating strategy management events and generating markdown reports.
+ *
+ * Collects strategy actions (cancel-scheduled, close-pending, partial-profit,
+ * partial-loss, trailing-stop, trailing-take, breakeven) in memory and provides
+ * methods to retrieve statistics, generate reports, and export to files.
+ *
+ * Unlike StrategyReportService which writes each event to disk immediately,
+ * this service accumulates events in ReportStorage instances (max 250 per
+ * symbol-strategy pair) for batch reporting.
+ *
+ * Features:
+ * - In-memory event accumulation with memoized storage per symbol-strategy pair
+ * - Statistical data extraction (event counts by action type)
+ * - Markdown report generation with configurable columns
+ * - File export with timestamped filenames
+ * - Selective or full cache clearing
+ *
+ * Lifecycle:
+ * - Call subscribe() to enable event collection
+ * - Events are collected automatically via cancelScheduled, closePending, etc.
+ * - Use getData(), getReport(), or dump() to retrieve accumulated data
+ * - Call unsubscribe() to disable collection and clear all data
+ *
+ * @example
+ * ```typescript
+ * strategyMarkdownService.subscribe();
+ *
+ * // Events are collected automatically during strategy execution
+ * // ...
+ *
+ * // Get statistics
+ * const stats = await strategyMarkdownService.getData("BTCUSDT", "my-strategy", "binance", "1h", true);
+ *
+ * // Generate markdown report
+ * const report = await strategyMarkdownService.getReport("BTCUSDT", "my-strategy", "binance", "1h", true);
+ *
+ * // Export to file
+ * await strategyMarkdownService.dump("BTCUSDT", "my-strategy", "binance", "1h", true);
+ *
+ * strategyMarkdownService.unsubscribe();
+ * ```
+ *
+ * @see StrategyReportService for immediate event persistence to JSON files
+ * @see Strategy for the high-level utility class that wraps this service
+ */
+declare class StrategyMarkdownService {
+    readonly loggerService: LoggerService;
+    readonly executionContextService: {
+        readonly context: IExecutionContext;
+    };
+    readonly strategyCoreService: StrategyCoreService;
+    /**
+     * Memoized factory for ReportStorage instances.
+     *
+     * Creates and caches ReportStorage per unique symbol-strategy-exchange-frame-backtest combination.
+     * Uses CREATE_KEY_FN for cache key generation.
+     *
+     * @internal
+     */
+    private getStorage;
+    /**
+     * Records a cancel-scheduled event when a scheduled signal is cancelled.
+     *
+     * Retrieves the scheduled signal from StrategyCoreService and stores
+     * the cancellation event in the appropriate ReportStorage.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param cancelId - Optional identifier for the cancellation reason
+     */
+    cancelScheduled: (symbol: string, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, cancelId?: string) => Promise<void>;
+    /**
+     * Records a close-pending event when a pending signal is closed.
+     *
+     * Retrieves the pending signal from StrategyCoreService and stores
+     * the close event in the appropriate ReportStorage.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param closeId - Optional identifier for the close reason
+     */
+    closePending: (symbol: string, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, closeId?: string) => Promise<void>;
+    /**
+     * Records a partial-profit event when a portion of the position is closed at profit.
+     *
+     * Stores the percentage closed and current price when partial profit-taking occurs.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to close (0-100)
+     * @param currentPrice - Current market price at time of partial close
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    partialProfit: (symbol: string, percentToClose: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Records a partial-loss event when a portion of the position is closed at loss.
+     *
+     * Stores the percentage closed and current price when partial loss-cutting occurs.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to close (0-100)
+     * @param currentPrice - Current market price at time of partial close
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    partialLoss: (symbol: string, percentToClose: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Records a trailing-stop event when the stop-loss is adjusted.
+     *
+     * Stores the percentage shift and current price when trailing stop moves.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage the stop-loss was shifted
+     * @param currentPrice - Current market price at time of adjustment
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    trailingStop: (symbol: string, percentShift: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Records a trailing-take event when the take-profit is adjusted.
+     *
+     * Stores the percentage shift and current price when trailing take-profit moves.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage the take-profit was shifted
+     * @param currentPrice - Current market price at time of adjustment
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    trailingTake: (symbol: string, percentShift: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Records a breakeven event when the stop-loss is moved to entry price.
+     *
+     * Stores the current price when breakeven protection is activated.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price at time of breakeven activation
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    breakeven: (symbol: string, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Retrieves aggregated statistics from accumulated strategy events.
+     *
+     * Returns counts for each action type and the full event list from the
+     * ReportStorage for the specified symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Name of the trading strategy
+     * @param exchangeName - Name of the exchange
+     * @param frameName - Timeframe name for backtest identification
+     * @param backtest - Whether to get backtest or live data
+     * @returns Promise resolving to StrategyStatisticsModel with event list and counts
+     * @throws Error if service not initialized (subscribe() not called)
+     */
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<StrategyStatisticsModel>;
+    /**
+     * Generates a markdown report from accumulated strategy events.
+     *
+     * Creates a formatted markdown document containing:
+     * - Header with symbol and strategy name
+     * - Table of all events with configurable columns
+     * - Summary statistics with counts by action type
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Name of the trading strategy
+     * @param exchangeName - Name of the exchange
+     * @param frameName - Timeframe name for backtest identification
+     * @param backtest - Whether to get backtest or live data
+     * @param columns - Column configuration for the event table
+     * @returns Promise resolving to formatted markdown string
+     * @throws Error if service not initialized (subscribe() not called)
+     */
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns[]) => Promise<string>;
+    /**
+     * Generates and saves a markdown report to disk.
+     *
+     * Creates the output directory if it doesn't exist and writes
+     * the report with a timestamped filename via Markdown.writeData().
+     *
+     * Filename format: `{symbol}_{strategyName}_{exchangeName}[_{frameName}_backtest|_live]-{timestamp}.md`
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Name of the trading strategy
+     * @param exchangeName - Name of the exchange
+     * @param frameName - Timeframe name for backtest identification
+     * @param backtest - Whether to dump backtest or live data
+     * @param path - Output directory path (default: "./dump/strategy")
+     * @param columns - Column configuration for the event table
+     * @returns Promise that resolves when file is written
+     * @throws Error if service not initialized (subscribe() not called)
+     */
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+    /**
+     * Clears accumulated events from storage.
+     *
+     * Can clear either a specific symbol-strategy pair or all stored data.
+     *
+     * @param payload - Optional filter to clear specific storage. If omitted, clears all.
+     * @param payload.symbol - Trading pair symbol
+     * @param payload.strategyName - Strategy name
+     * @param payload.exchangeName - Exchange name
+     * @param payload.frameName - Frame name
+     * @param payload.backtest - Backtest mode flag
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+        backtest: boolean;
+    }) => Promise<void>;
+    /**
+     * Initializes the service for event collection.
+     *
+     * Must be called before any events can be collected or reports generated.
+     * Uses singleshot pattern to ensure only one subscription exists at a time.
+     *
+     * @returns Cleanup function that clears the subscription and all accumulated data
+     */
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Stops event collection and clears all accumulated data.
+     *
+     * Invokes the cleanup function returned by subscribe(), which clears
+     * both the subscription and all ReportStorage instances.
+     * Safe to call multiple times - only acts if subscription exists.
+     */
+    unsubscribe: () => Promise<void>;
+}
+
+/**
+ * Utility class for accessing strategy management reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by StrategyMarkdownService from strategy management events.
+ *
+ * Features:
+ * - Statistical data extraction (event counts by action type)
+ * - Markdown report generation with event tables
+ * - File export to disk
+ *
+ * Data source:
+ * - StrategyMarkdownService receives events via direct method calls
+ * - Accumulates events in ReportStorage (max 250 events per symbol-strategy pair)
+ * - Events include: cancel-scheduled, close-pending, partial-profit, partial-loss,
+ *   trailing-stop, trailing-take, breakeven
+ *
+ * @example
+ * ```typescript
+ * import { Strategy } from "./classes/Strategy";
+ *
+ * // Get statistical data for BTCUSDT:my-strategy
+ * const stats = await Strategy.getData("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * console.log(`Total events: ${stats.totalEvents}`);
+ * console.log(`Partial profit events: ${stats.partialProfitCount}`);
+ *
+ * // Generate markdown report
+ * const markdown = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * console.log(markdown); // Formatted table with all events
+ *
+ * // Export report to file
+ * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }); // Saves to ./dump/strategy/
+ * ```
+ */
+declare class StrategyUtils {
+    /**
+     * Retrieves statistical data from accumulated strategy events.
+     *
+     * Delegates to StrategyMarkdownService.getData() which reads from ReportStorage.
+     * Returns aggregated metrics calculated from all strategy events.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param backtest - Whether to get backtest data (default: false)
+     * @returns Promise resolving to StrategyStatisticsModel object with counts and event list
+     *
+     * @example
+     * ```typescript
+     * const stats = await Strategy.getData("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+     *
+     * console.log(`Total events: ${stats.totalEvents}`);
+     * console.log(`Partial profit: ${stats.partialProfitCount}`);
+     * console.log(`Trailing stop: ${stats.trailingStopCount}`);
+     *
+     * // Iterate through all events
+     * for (const event of stats.eventList) {
+     *   console.log(`Signal ${event.signalId}: ${event.action} at ${event.currentPrice}`);
+     * }
+     * ```
+     */
+    getData: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean) => Promise<StrategyStatisticsModel>;
+    /**
+     * Generates markdown report with all strategy events for a symbol-strategy pair.
+     *
+     * Creates formatted table containing:
+     * - Symbol
+     * - Strategy
+     * - Signal ID
+     * - Action (cancel-scheduled, close-pending, partial-profit, etc.)
+     * - Price
+     * - Percent values (% To Close, % Shift)
+     * - Cancel/Close IDs
+     * - Timestamp (ISO 8601)
+     * - Mode (Backtest/Live)
+     *
+     * Also includes summary statistics at the end with counts by action type.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param backtest - Whether to get backtest data (default: false)
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise resolving to markdown formatted report string
+     *
+     * @example
+     * ```typescript
+     * const markdown = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+     * console.log(markdown);
+     *
+     * // Output:
+     * // # Strategy Report: BTCUSDT:my-strategy
+     * //
+     * // | Symbol | Strategy | Signal ID | Action | Price | ... |
+     * // | --- | --- | --- | --- | --- | ... |
+     * // | BTCUSDT | my-strategy | abc123 | partial-profit | 50100.00000000 USD | ... |
+     * //
+     * // **Total events:** 5
+     * // - Cancel scheduled: 0
+     * // - Close pending: 1
+     * // - Partial profit: 2
+     * // ...
+     * ```
+     */
+    getReport: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, columns?: Columns[]) => Promise<string>;
+    /**
+     * Generates and saves markdown report to file.
+     *
+     * Creates directory if it doesn't exist.
+     * Filename format: {symbol}_{strategyName}_{exchangeName}_{frameName|live}-{timestamp}.md
+     *
+     * Delegates to StrategyMarkdownService.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 context - Strategy context with strategyName, exchangeName, frameName
+     * @param backtest - Whether to dump backtest data (default: false)
+     * @param path - Output directory path (default: "./dump/strategy")
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise that resolves when file is written
+     *
+     * @example
+     * ```typescript
+     * // Save to default path: ./dump/strategy/BTCUSDT_my-strategy_binance_1h_backtest-{timestamp}.md
+     * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true);
+     *
+     * // Save to custom path
+     * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true, "./reports/strategy");
+     *
+     * // After multiple symbols backtested, export all reports
+     * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+     *   await Strategy.dump(symbol, { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true, "./backtest-results");
+     * }
+     * ```
+     */
+    dump: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, path?: string, columns?: Columns[]) => Promise<void>;
+}
+/**
+ * Global singleton instance of StrategyUtils.
+ * Provides static-like access to strategy management reporting methods.
+ *
+ * @example
+ * ```typescript
+ * import { Strategy } from "backtest-kit";
+ *
+ * // Usage same as StrategyUtils methods
+ * const stats = await Strategy.getData("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * const report = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * ```
+ */
+declare const Strategy: StrategyUtils;
+
+/**
+ * Proxy wrapper for user-defined action handlers with automatic error capture.
+ *
+ * Wraps all IPublicAction methods with trycatch to prevent user code errors from crashing the system.
+ * All errors are logged, sent to errorEmitter, and returned as null (non-breaking).
+ *
+ * Key features:
+ * - Automatic error catching and logging for all action methods
+ * - Safe execution of partial user implementations (missing methods return null)
+ * - Consistent error capture across all action lifecycle events
+ * - Non-breaking failure mode (errors logged but execution continues)
+ *
+ * Architecture:
+ * - Private constructor enforces factory pattern via fromInstance()
+ * - Each method checks if target implements the method before calling
+ * - Errors caught with fallback handler (warn log + errorEmitter)
+ * - Returns null on error to prevent undefined behavior
+ *
+ * Used by:
+ * - ClientAction to wrap user-provided action handlers
+ * - ActionCoreService to safely invoke action callbacks
+ *
+ * @example
+ * ```typescript
+ * // Create proxy from user implementation
+ * const userAction = {
+ *   signal: async (event) => {
+ *     // User code that might throw
+ *     throw new Error('User error');
+ *   }
+ * };
+ *
+ * const proxy = ActionProxy.fromInstance(userAction);
+ *
+ * // Error is caught and logged, execution continues
+ * await proxy.signal(event); // Logs error, returns null
+ * await proxy.dispose(); // Safe call even though not implemented
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Partial implementation is safe
+ * const partialAction = {
+ *   init: async () => console.log('Initialized'),
+ *   // Other methods not implemented
+ * };
+ *
+ * const proxy = ActionProxy.fromInstance(partialAction);
+ * await proxy.init(); // Works
+ * await proxy.signal(event); // Returns null (not implemented)
+ * ```
+ */
+declare class ActionProxy implements IPublicAction {
+    readonly _target: Partial<IPublicAction>;
+    /**
+     * Creates a new ActionProxy instance.
+     *
+     * @param _target - Partial action implementation to wrap with error capture
+     * @private Use ActionProxy.fromInstance() instead
+     */
+    private constructor();
+    /**
+     * Initializes the action handler with error capture.
+     *
+     * Wraps the user's init() method in trycatch to prevent initialization errors from crashing the system.
+     * If the target doesn't implement init(), this method safely returns undefined.
+     *
+     * @returns Promise resolving to user's init() result or undefined if not implemented
+     */
+    init(): Promise<any>;
+    /**
+     * Handles signal events from all modes with error capture.
+     *
+     * Wraps the user's signal() method to catch and log any errors.
+     * Called on every tick/candle when strategy is evaluated.
+     *
+     * @param event - Signal state result with action, state, signal data, and context
+     * @returns Promise resolving to user's signal() result or null on error
+     */
+    signal(event: IStrategyTickResult): Promise<any>;
+    /**
+     * Handles signal events from live trading only with error capture.
+     *
+     * Wraps the user's signalLive() method to catch and log any errors.
+     * Called every tick in live mode.
+     *
+     * @param event - Signal state result from live trading
+     * @returns Promise resolving to user's signalLive() result or null on error
+     */
+    signalLive(event: IStrategyTickResult): Promise<any>;
+    /**
+     * Handles signal events from backtest only with error capture.
+     *
+     * Wraps the user's signalBacktest() method to catch and log any errors.
+     * Called every candle in backtest mode.
+     *
+     * @param event - Signal state result from backtest
+     * @returns Promise resolving to user's signalBacktest() result or null on error
+     */
+    signalBacktest(event: IStrategyTickResult): Promise<any>;
+    /**
+     * Handles breakeven events with error capture.
+     *
+     * Wraps the user's breakevenAvailable() method to catch and log any errors.
+     * Called once per signal when stop-loss is moved to entry price.
+     *
+     * @param event - Breakeven milestone data with signal info, current price, timestamp
+     * @returns Promise resolving to user's breakevenAvailable() result or null on error
+     */
+    breakevenAvailable(event: BreakevenContract): Promise<any>;
+    /**
+     * Handles partial profit level events with error capture.
+     *
+     * Wraps the user's partialProfitAvailable() method to catch and log any errors.
+     * Called once per profit level per signal (10%, 20%, 30%, etc).
+     *
+     * @param event - Profit milestone data with signal info, level, price, timestamp
+     * @returns Promise resolving to user's partialProfitAvailable() result or null on error
+     */
+    partialProfitAvailable(event: PartialProfitContract): Promise<any>;
+    /**
+     * Handles partial loss level events with error capture.
+     *
+     * Wraps the user's partialLossAvailable() method to catch and log any errors.
+     * Called once per loss level per signal (-10%, -20%, -30%, etc).
+     *
+     * @param event - Loss milestone data with signal info, level, price, timestamp
+     * @returns Promise resolving to user's partialLossAvailable() result or null on error
+     */
+    partialLossAvailable(event: PartialLossContract): Promise<any>;
+    /**
+     * Handles scheduled ping events with error capture.
+     *
+     * Wraps the user's pingScheduled() method to catch and log any errors.
+     * Called every minute while a scheduled signal is waiting for activation.
+     *
+     * @param event - Scheduled signal monitoring data with symbol, strategy info, signal data, timestamp
+     * @returns Promise resolving to user's pingScheduled() result or null on error
+     */
+    pingScheduled(event: SchedulePingContract): Promise<any>;
+    /**
+     * Handles active ping events with error capture.
+     *
+     * Wraps the user's pingActive() method to catch and log any errors.
+     * Called every minute while a pending signal is active (position open).
+     *
+     * @param event - Active pending signal monitoring data with symbol, strategy info, signal data, timestamp
+     * @returns Promise resolving to user's pingActive() result or null on error
+     */
+    pingActive(event: ActivePingContract): Promise<any>;
+    /**
+     * Handles risk rejection events with error capture.
+     *
+     * Wraps the user's riskRejection() method to catch and log any errors.
+     * Called only when signal is rejected by risk management validation.
+     *
+     * @param event - Risk rejection data with symbol, pending signal, rejection reason, timestamp
+     * @returns Promise resolving to user's riskRejection() result or null on error
+     */
+    riskRejection(event: RiskContract): Promise<any>;
+    /**
+     * Cleans up resources with error capture.
+     *
+     * Wraps the user's dispose() method to catch and log any errors.
      * Called once when strategy execution ends.
      *
      * @returns Promise resolving to user's dispose() result or null on error
@@ -13372,6 +14720,20 @@ declare const schedulePingSubject: Subject<SchedulePingContract>;
  * Allows users to track active signal lifecycle and implement custom dynamic management logic.
  */
 declare const activePingSubject: Subject<ActivePingContract>;
+/**
+ * Strategy management signal emitter.
+ * Emits when strategy management actions are executed:
+ * - cancel-scheduled: Scheduled signal cancelled
+ * - close-pending: Pending signal closed
+ * - partial-profit: Partial close at profit level
+ * - partial-loss: Partial close at loss level
+ * - trailing-stop: Stop-loss adjusted
+ * - trailing-take: Take-profit adjusted
+ * - breakeven: Stop-loss moved to entry price
+ *
+ * Used by StrategyReportService and StrategyMarkdownService for event logging and reporting.
+ */
+declare const strategyCommitSubject: Subject<StrategyCommitContract>;
 
 declare const emitters_activePingSubject: typeof activePingSubject;
 declare const emitters_breakevenSubject: typeof breakevenSubject;
@@ -13390,12 +14752,13 @@ declare const emitters_schedulePingSubject: typeof schedulePingSubject;
 declare const emitters_signalBacktestEmitter: typeof signalBacktestEmitter;
 declare const emitters_signalEmitter: typeof signalEmitter;
 declare const emitters_signalLiveEmitter: typeof signalLiveEmitter;
+declare const emitters_strategyCommitSubject: typeof strategyCommitSubject;
 declare const emitters_validationSubject: typeof validationSubject;
 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_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_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, 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_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -13453,109 +14816,48 @@ interface IParseArgsResult extends IParseArgsParams {
  * - --backtest: Enable backtest mode (boolean flag)
  * - --paper: Enable paper trading mode (boolean flag)
  * - --live: Enable live trading mode (boolean flag)
- *
- * @param params - Optional default values for parameters
- * @param params.symbol - Default trading pair symbol
- * @param params.strategyName - Default strategy name
- * @param params.exchangeName - Default exchange name
- * @param params.frameName - Default timeframe
- * @returns Parsed configuration with all parameters and mode flags
- *
- * @example
- * ```typescript
- * // Parse args with defaults
- * const config = parseArgs({
- *   symbol: "BTCUSDT",
- *   strategyName: "rsi_divergence",
- *   exchangeName: "binance",
- *   frameName: "1h"
- * });
- *
- * // Command: node app.js --backtest
- * // Result: { symbol: "BTCUSDT", ..., backtest: true, paper: false, live: false }
- * ```
- */
-declare const parseArgs: ({ symbol, strategyName, exchangeName, frameName, }?: Partial<IParseArgsParams>) => IParseArgsResult;
-
-/**
- * Retrieves a value from an object using a given path.
- *
- * @param object - The object from which to retrieve the value.
- * @param path - The path to the desired value, either as an array or dot-separated string.
- * @returns - The value at the specified path, or undefined if it does not exist.
- */
-declare const get: (object: any, path: any) => any;
-
-/**
- * Updates the value of a nested object property using a specific path.
- *
- * @param object - The object to update.
- * @param path - The path to the property. Can be either a dot-separated string or an array of strings.
- * @param value - The new value to set for the property.
- * @returns - Returns true if the property was successfully updated, false otherwise.
- */
-declare const set: (object: any, path: any, value: any) => boolean;
-
-/**
- * Logger service with automatic context injection.
- *
- * Features:
- * - Delegates to user-provided logger via setLogger()
- * - Automatically appends method context (strategyName, exchangeName, frameName)
- * - Automatically appends execution context (symbol, when, backtest)
- * - Defaults to NOOP_LOGGER if no logger configured
- *
- * Used throughout the framework for consistent logging with context.
- */
-declare class LoggerService implements ILogger {
-    private readonly methodContextService;
-    private readonly executionContextService;
-    private _commonLogger;
-    /**
-     * Gets current method context if available.
-     * Contains strategyName, exchangeName, frameName from MethodContextService.
-     */
-    private get methodContext();
-    /**
-     * Gets current execution context if available.
-     * Contains symbol, when, backtest from ExecutionContextService.
-     */
-    private get executionContext();
-    /**
-     * Logs general-purpose message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    log: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Logs debug-level message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    debug: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Logs info-level message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    info: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Logs warning-level message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    warn: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Sets custom logger implementation.
-     *
-     * @param logger - Custom logger implementing ILogger interface
-     */
-    setLogger: (logger: ILogger) => void;
-}
+ *
+ * @param params - Optional default values for parameters
+ * @param params.symbol - Default trading pair symbol
+ * @param params.strategyName - Default strategy name
+ * @param params.exchangeName - Default exchange name
+ * @param params.frameName - Default timeframe
+ * @returns Parsed configuration with all parameters and mode flags
+ *
+ * @example
+ * ```typescript
+ * // Parse args with defaults
+ * const config = parseArgs({
+ *   symbol: "BTCUSDT",
+ *   strategyName: "rsi_divergence",
+ *   exchangeName: "binance",
+ *   frameName: "1h"
+ * });
+ *
+ * // Command: node app.js --backtest
+ * // Result: { symbol: "BTCUSDT", ..., backtest: true, paper: false, live: false }
+ * ```
+ */
+declare const parseArgs: ({ symbol, strategyName, exchangeName, frameName, }?: Partial<IParseArgsParams>) => IParseArgsResult;
+
+/**
+ * Retrieves a value from an object using a given path.
+ *
+ * @param object - The object from which to retrieve the value.
+ * @param path - The path to the desired value, either as an array or dot-separated string.
+ * @returns - The value at the specified path, or undefined if it does not exist.
+ */
+declare const get: (object: any, path: any) => any;
+
+/**
+ * Updates the value of a nested object property using a specific path.
+ *
+ * @param object - The object to update.
+ * @param path - The path to the property. Can be either a dot-separated string or an array of strings.
+ * @param value - The new value to set for the property.
+ * @returns - Returns true if the property was successfully updated, false otherwise.
+ */
+declare const set: (object: any, path: any, value: any) => boolean;
 
 /**
  * Client implementation for exchange data access.
@@ -14479,7 +15781,7 @@ declare class BreakevenConnectionService implements IBreakeven {
  * Maps all keys of IStrategy to any type.
  * Used for dynamic method routing in StrategyConnectionService.
  */
-type TStrategy$1 = {
+type TStrategy = {
     [key in keyof IStrategy]: any;
 };
 /**
@@ -14502,7 +15804,7 @@ type TStrategy$1 = {
  * // Routes to correct strategy instance for symbol-strategy pair
  * ```
  */
-declare class StrategyConnectionService implements TStrategy$1 {
+declare class StrategyConnectionService implements TStrategy {
     readonly loggerService: LoggerService;
     readonly executionContextService: {
         readonly context: IExecutionContext;
@@ -15105,783 +16407,388 @@ declare class ClientAction implements IAction {
      *     onSignal: (event, actionName, strategyName, frameName, backtest) => {
      *       console.log(`Signal: ${event.action}`);
      *     }
-     *   },
-     *   logger: loggerService,
-     *   strategyName: "rsi_divergence",
-     *   exchangeName: "binance",
-     *   frameName: "1h",
-     *   backtest: false
-     * });
-     *
-     * await actionClient.signal({
-     *   action: 'opened',
-     *   signal: { id: '123', side: 'long' },
-     *   backtest: false
-     * });
-     *
-     * await actionClient.dispose();
-     * ```
-     */
-    constructor(params: IActionParams);
-    /**
-     * Initializes handler instance using singleshot pattern.
-     * Ensures initialization happens exactly once.
-     */
-    waitForInit: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-    /**
-     * Handles signal events from all modes (live + backtest).
-     */
-    signal(event: IStrategyTickResult): Promise<void>;
-    /**
-     * Handles signal events from live trading only.
-     */
-    signalLive(event: IStrategyTickResult): Promise<void>;
-    /**
-     * Handles signal events from backtest only.
-     */
-    signalBacktest(event: IStrategyTickResult): Promise<void>;
-    /**
-     * Handles breakeven events when stop-loss is moved to entry price.
-     */
-    breakevenAvailable(event: BreakevenContract): Promise<void>;
-    /**
-     * Handles partial profit level events (10%, 20%, 30%, etc).
-     */
-    partialProfitAvailable(event: PartialProfitContract): Promise<void>;
-    /**
-     * Handles partial loss level events (-10%, -20%, -30%, etc).
-     */
-    partialLossAvailable(event: PartialLossContract): Promise<void>;
-    /**
-     * Handles scheduled ping events during scheduled signal monitoring.
-     */
-    pingScheduled(event: SchedulePingContract): Promise<void>;
-    /**
-     * Handles active ping events during active pending signal monitoring.
-     */
-    pingActive(event: ActivePingContract): Promise<void>;
-    /**
-     * Handles risk rejection events when signals fail risk validation.
-     */
-    riskRejection(event: RiskContract): Promise<void>;
-    /**
-     * Cleans up resources and subscriptions when action handler is no longer needed.
-     * Uses singleshot pattern to ensure cleanup happens exactly once.
-     */
-    dispose: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-/**
- * Type definition for action methods.
- * Maps all keys of IAction to any type.
- * Used for dynamic method routing in ActionConnectionService.
- */
-type TAction = {
-    [key in keyof IAction]: any;
-};
-/**
- * Connection service routing action operations to correct ClientAction instance.
- *
- * Routes action calls to the appropriate action implementation
- * based on the provided actionName parameter. Uses memoization to cache
- * ClientAction instances for performance.
- *
- * Key features:
- * - Explicit action routing via actionName parameter
- * - Memoized ClientAction instances by actionName, strategyName, frameName
- * - Event routing to action handlers
- *
- * @example
- * ```typescript
- * // Used internally by framework
- * await actionConnectionService.signal(
- *   event,
- *   {
- *     actionName: "telegram-notifier",
- *     strategyName: "rsi_divergence",
- *     exchangeName: "binance",
- *     frameName: "1h",
- *     backtest: false
- *   }
- * );
- * ```
- */
-declare class ActionConnectionService implements TAction {
-    private readonly loggerService;
-    private readonly actionSchemaService;
-    /**
-     * Retrieves memoized ClientAction instance for given action name, strategy, exchange, frame and backtest mode.
-     *
-     * Creates ClientAction on first call, returns cached instance on subsequent calls.
-     * Cache key includes strategyName, exchangeName and frameName to isolate action per strategy-frame pair.
-     *
-     * @param actionName - Name of registered action schema
-     * @param strategyName - Strategy name
-     * @param exchangeName - Exchange name
-     * @param frameName - Frame name (empty string for live)
-     * @param backtest - True if backtest mode, false if live mode
-     * @returns Configured ClientAction instance
-     */
-    getAction: ((actionName: ActionName, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => ClientAction) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientAction>;
-    /**
-     * Initializes the ClientAction instance for the given action name.
-     *
-     * Calls waitForInit() on the action instance to load persisted state.
-     *
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    initFn: (backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes signal event to appropriate ClientAction instance.
-     *
-     * @param event - Signal event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    signal: (event: IStrategyTickResult, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes signalLive event to appropriate ClientAction instance.
-     *
-     * @param event - Signal event data from live trading
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    signalLive: (event: IStrategyTickResult, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes signalBacktest event to appropriate ClientAction instance.
-     *
-     * @param event - Signal event data from backtest
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    signalBacktest: (event: IStrategyTickResult, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes breakeven event to appropriate ClientAction instance.
-     *
-     * @param event - Breakeven event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    breakevenAvailable: (event: BreakevenContract, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes partialProfit event to appropriate ClientAction instance.
-     *
-     * @param event - Partial profit event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    partialProfitAvailable: (event: PartialProfitContract, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes partialLoss event to appropriate ClientAction instance.
-     *
-     * @param event - Partial loss event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    partialLossAvailable: (event: PartialLossContract, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes scheduled ping event to appropriate ClientAction instance.
+     *   },
+     *   logger: loggerService,
+     *   strategyName: "rsi_divergence",
+     *   exchangeName: "binance",
+     *   frameName: "1h",
+     *   backtest: false
+     * });
      *
-     * @param event - Scheduled ping event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
-     */
-    pingScheduled: (event: SchedulePingContract, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
-    /**
-     * Routes active ping event to appropriate ClientAction instance.
+     * await actionClient.signal({
+     *   action: 'opened',
+     *   signal: { id: '123', side: 'long' },
+     *   backtest: false
+     * });
      *
-     * @param event - Active ping event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     * await actionClient.dispose();
+     * ```
      */
-    pingActive: (event: ActivePingContract, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
+    constructor(params: IActionParams);
     /**
-     * Routes riskRejection event to appropriate ClientAction instance.
-     *
-     * @param event - Risk rejection event data
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     * Initializes handler instance using singleshot pattern.
+     * Ensures initialization happens exactly once.
      */
-    riskRejection: (event: RiskContract, backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
+    waitForInit: (() => Promise<void>) & functools_kit.ISingleshotClearable;
     /**
-     * Disposes the ClientAction instance for the given action name.
-     *
-     * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     * Handles signal events from all modes (live + backtest).
      */
-    dispose: (backtest: boolean, context: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<void>;
+    signal(event: IStrategyTickResult): Promise<void>;
     /**
-     * Clears the cached ClientAction instance for the given action name.
-     *
-     * @param payload - Optional payload with actionName, strategyName, exchangeName, frameName, backtest (clears all if not provided)
+     * Handles signal events from live trading only.
      */
-    clear: (payload?: {
-        actionName: ActionName;
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-        backtest: boolean;
-    }) => Promise<void>;
-}
-
-/**
- * Type definition for exchange methods.
- * Maps all keys of IExchange to any type.
- * Used for dynamic method routing in ExchangeCoreService.
- */
-type TExchange = {
-    [key in keyof IExchange]: any;
-};
-/**
- * Global service for exchange operations with execution context injection.
- *
- * Wraps ExchangeConnectionService with ExecutionContextService to inject
- * symbol, when, and backtest parameters into the execution context.
- *
- * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
- */
-declare class ExchangeCoreService implements TExchange {
-    private readonly loggerService;
-    private readonly exchangeConnectionService;
-    private readonly methodContextService;
-    private readonly exchangeValidationService;
+    signalLive(event: IStrategyTickResult): Promise<void>;
     /**
-     * Validates exchange configuration.
-     * Memoized to avoid redundant validations for the same exchange.
-     * Logs validation activity.
-     * @param exchangeName - Name of the exchange to validate
-     * @returns Promise that resolves when validation is complete
+     * Handles signal events from backtest only.
      */
-    private validate;
+    signalBacktest(event: IStrategyTickResult): Promise<void>;
     /**
-     * Fetches historical candles with execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval (e.g., "1m", "1h")
-     * @param limit - Maximum number of candles to fetch
-     * @param when - Timestamp for context (used in backtest mode)
-     * @param backtest - Whether running in backtest mode
-     * @returns Promise resolving to array of candles
+     * Handles breakeven events when stop-loss is moved to entry price.
      */
-    getCandles: (symbol: string, interval: CandleInterval, limit: number, when: Date, backtest: boolean) => Promise<ICandleData[]>;
+    breakevenAvailable(event: BreakevenContract): Promise<void>;
     /**
-     * Fetches future candles (backtest mode only) with execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval
-     * @param limit - Maximum number of candles to fetch
-     * @param when - Timestamp for context
-     * @param backtest - Whether running in backtest mode (must be true)
-     * @returns Promise resolving to array of future candles
+     * Handles partial profit level events (10%, 20%, 30%, etc).
      */
-    getNextCandles: (symbol: string, interval: CandleInterval, limit: number, when: Date, backtest: boolean) => Promise<ICandleData[]>;
+    partialProfitAvailable(event: PartialProfitContract): Promise<void>;
     /**
-     * Calculates VWAP with execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param when - Timestamp for context
-     * @param backtest - Whether running in backtest mode
-     * @returns Promise resolving to VWAP price
+     * Handles partial loss level events (-10%, -20%, -30%, etc).
      */
-    getAveragePrice: (symbol: string, when: Date, backtest: boolean) => Promise<number>;
+    partialLossAvailable(event: PartialLossContract): Promise<void>;
     /**
-     * Formats price with execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param price - Price to format
-     * @param when - Timestamp for context
-     * @param backtest - Whether running in backtest mode
-     * @returns Promise resolving to formatted price string
+     * Handles scheduled ping events during scheduled signal monitoring.
      */
-    formatPrice: (symbol: string, price: number, when: Date, backtest: boolean) => Promise<string>;
+    pingScheduled(event: SchedulePingContract): Promise<void>;
     /**
-     * Formats quantity with execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param quantity - Quantity to format
-     * @param when - Timestamp for context
-     * @param backtest - Whether running in backtest mode
-     * @returns Promise resolving to formatted quantity string
+     * Handles active ping events during active pending signal monitoring.
      */
-    formatQuantity: (symbol: string, quantity: number, when: Date, backtest: boolean) => Promise<string>;
+    pingActive(event: ActivePingContract): Promise<void>;
     /**
-     * Fetches order book with execution context.
-     *
-     * Sets up execution context with the provided when/backtest parameters.
-     * The exchange implementation will receive time range parameters but may
-     * choose to use them (backtest) or ignore them (live).
-     *
-     * @param symbol - Trading pair symbol
-     * @param when - Timestamp for context
-     * @param backtest - Whether running in backtest mode
-     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
-     * @returns Promise resolving to order book data
+     * Handles risk rejection events when signals fail risk validation.
      */
-    getOrderBook: (symbol: string, when: Date, backtest: boolean, depth?: number) => Promise<IOrderBookData>;
+    riskRejection(event: RiskContract): Promise<void>;
     /**
-     * Fetches raw candles with flexible date/limit parameters and execution context.
-     *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval (e.g., "1m", "1h")
-     * @param when - Timestamp for context (used in backtest mode)
-     * @param backtest - Whether running in backtest mode
-     * @param limit - Optional number of candles to fetch
-     * @param sDate - Optional start date in milliseconds
-     * @param eDate - Optional end date in milliseconds
-     * @returns Promise resolving to array of candles
+     * Cleans up resources and subscriptions when action handler is no longer needed.
+     * Uses singleshot pattern to ensure cleanup happens exactly once.
      */
-    getRawCandles: (symbol: string, interval: CandleInterval, when: Date, backtest: boolean, limit?: number, sDate?: number, eDate?: number) => Promise<ICandleData[]>;
+    dispose: (() => Promise<void>) & functools_kit.ISingleshotClearable;
 }
 
 /**
- * Type definition for strategy methods.
- * Maps all keys of IStrategy to any type.
- * Used for dynamic method routing in StrategyCoreService.
+ * Type definition for action methods.
+ * Maps all keys of IAction to any type.
+ * Used for dynamic method routing in ActionConnectionService.
  */
-type TStrategy = {
-    [key in keyof IStrategy]: any;
+type TAction = {
+    [key in keyof IAction]: any;
 };
 /**
- * Global service for strategy operations with execution context injection.
+ * Connection service routing action operations to correct ClientAction instance.
  *
- * Wraps StrategyConnectionService with ExecutionContextService to inject
- * symbol, when, and backtest parameters into the execution context.
+ * Routes action calls to the appropriate action implementation
+ * based on the provided actionName parameter. Uses memoization to cache
+ * ClientAction instances for performance.
  *
- * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
+ * Key features:
+ * - Explicit action routing via actionName parameter
+ * - Memoized ClientAction instances by actionName, strategyName, frameName
+ * - Event routing to action handlers
+ *
+ * @example
+ * ```typescript
+ * // Used internally by framework
+ * await actionConnectionService.signal(
+ *   event,
+ *   {
+ *     actionName: "telegram-notifier",
+ *     strategyName: "rsi_divergence",
+ *     exchangeName: "binance",
+ *     frameName: "1h",
+ *     backtest: false
+ *   }
+ * );
+ * ```
  */
-declare class StrategyCoreService implements TStrategy {
+declare class ActionConnectionService implements TAction {
     private readonly loggerService;
-    private readonly strategyConnectionService;
-    private readonly strategySchemaService;
-    private readonly riskValidationService;
-    private readonly strategyValidationService;
-    private readonly exchangeValidationService;
-    private readonly frameValidationService;
+    private readonly actionSchemaService;
     /**
-     * Validates strategy and associated risk configuration.
+     * Retrieves memoized ClientAction instance for given action name, strategy, exchange, frame and backtest mode.
      *
-     * Memoized to avoid redundant validations for the same symbol-strategy-exchange-frame combination.
-     * Logs validation activity.
-     * @param symbol - Trading pair symbol
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise that resolves when validation is complete
+     * Creates ClientAction on first call, returns cached instance on subsequent calls.
+     * Cache key includes strategyName, exchangeName and frameName to isolate action per strategy-frame pair.
+     *
+     * @param actionName - Name of registered action schema
+     * @param strategyName - Strategy name
+     * @param exchangeName - Exchange name
+     * @param frameName - Frame name (empty string for live)
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Configured ClientAction instance
      */
-    private validate;
+    getAction: ((actionName: ActionName, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => ClientAction) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientAction>;
+    /**
+     * Initializes the ClientAction instance for the given action name.
+     *
+     * Calls waitForInit() on the action instance to load persisted state.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     */
+    initFn: (backtest: boolean, context: {
+        actionName: ActionName;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
     /**
-     * Retrieves the currently active pending signal for the symbol.
-     * If no active signal exists, returns null.
-     * Used internally for monitoring TP/SL and time expiration.
+     * Routes signal event to appropriate ClientAction instance.
      *
+     * @param event - Signal event data
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to pending signal or null
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    getPendingSignal: (backtest: boolean, symbol: string, context: {
+    signal: (event: IStrategyTickResult, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<ISignalRow | null>;
+    }) => Promise<void>;
     /**
-     * Retrieves the currently active scheduled signal for the symbol.
-     * If no scheduled signal exists, returns null.
-     * Used internally for monitoring scheduled signal activation.
+     * Routes signalLive event to appropriate ClientAction instance.
      *
+     * @param event - Signal event data from live trading
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to scheduled signal or null
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    getScheduledSignal: (backtest: boolean, symbol: string, context: {
+    signalLive: (event: IStrategyTickResult, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<IScheduledSignalRow | null>;
+    }) => Promise<void>;
     /**
-     * Checks if breakeven threshold has been reached for the current pending signal.
-     *
-     * Validates strategy existence and delegates to connection service
-     * to check if price has moved far enough to cover transaction costs.
-     *
-     * Does not require execution context as this is a state query operation.
+     * Routes signalBacktest event to appropriate ClientAction instance.
      *
+     * @param event - Signal event data from backtest
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param currentPrice - Current market price to check against threshold
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
-     *
-     * @example
-     * ```typescript
-     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
-     * const canBreakeven = await strategyCoreService.getBreakeven(
-     *   false,
-     *   "BTCUSDT",
-     *   100.5,
-     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
-     * );
-     * // Returns true (price >= 100.4)
-     *
-     * if (canBreakeven) {
-     *   await strategyCoreService.breakeven(false, "BTCUSDT", 100.5, context);
-     * }
-     * ```
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    getBreakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+    signalBacktest: (event: IStrategyTickResult, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<boolean>;
+    }) => Promise<void>;
     /**
-     * Checks if the strategy has been stopped.
-     *
-     * Validates strategy existence and delegates to connection service
-     * to retrieve the stopped state from the strategy instance.
+     * Routes breakeven event to appropriate ClientAction instance.
      *
+     * @param event - Breakeven event data
      * @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 strategy is stopped, false otherwise
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    getStopped: (backtest: boolean, symbol: string, context: {
+    breakevenAvailable: (event: BreakevenContract, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<boolean>;
+    }) => Promise<void>;
     /**
-     * Checks signal status at a specific timestamp.
-     *
-     * Wraps strategy tick() with execution context containing symbol, timestamp,
-     * and backtest mode flag.
+     * Routes partialProfit event to appropriate ClientAction instance.
      *
-     * @param symbol - Trading pair symbol
-     * @param when - Timestamp for tick evaluation
+     * @param event - Partial profit event data
      * @param backtest - Whether running in backtest mode
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Discriminated union of tick result (idle, opened, active, closed)
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    tick: (symbol: string, when: Date, backtest: boolean, context: {
+    partialProfitAvailable: (event: PartialProfitContract, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<IStrategyTickResult>;
+    }) => Promise<void>;
     /**
-     * Runs fast backtest against candle array.
-     *
-     * Wraps strategy backtest() with execution context containing symbol,
-     * timestamp, and backtest mode flag.
+     * Routes partialLoss event to appropriate ClientAction instance.
      *
-     * @param symbol - Trading pair symbol
-     * @param candles - Array of historical candles to test against
-     * @param when - Starting timestamp for backtest
-     * @param backtest - Whether running in backtest mode (typically true)
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Closed signal result with PNL
+     * @param event - Partial loss event data
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    backtest: (symbol: string, candles: ICandleData[], when: Date, backtest: boolean, context: {
+    partialLossAvailable: (event: PartialLossContract, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<IStrategyBacktestResult>;
+    }) => Promise<void>;
     /**
-     * Stops the strategy from generating new signals.
-     *
-     * Delegates to StrategyConnectionService.stop() to set internal flag.
-     * Does not require execution context.
+     * Routes scheduled ping event to appropriate ClientAction instance.
      *
+     * @param event - Scheduled ping event data
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param ctx - Context with strategyName, exchangeName, frameName
-     * @returns Promise that resolves when stop flag is set
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    stopStrategy: (backtest: boolean, symbol: string, context: {
+    pingScheduled: (event: SchedulePingContract, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
     /**
-     * Cancels the scheduled signal without stopping the strategy.
-     *
-     * Delegates to StrategyConnectionService.cancelScheduled() to clear scheduled signal
-     * and emit cancelled event through emitters.
-     * Does not require execution context.
+     * Routes active ping event to appropriate ClientAction instance.
      *
+     * @param event - Active ping event data
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param ctx - Context with strategyName, exchangeName, frameName
-     * @param cancelId - Optional cancellation ID for user-initiated cancellations
-     * @returns Promise that resolves when scheduled signal is cancelled
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    cancelScheduled: (backtest: boolean, symbol: string, context: {
+    pingActive: (event: ActivePingContract, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, cancelId?: string) => Promise<void>;
+    }) => Promise<void>;
     /**
-     * Closes the pending signal without stopping the strategy.
-     *
-     * Clears the pending signal (active position).
-     * Does NOT affect scheduled signals or strategy operation.
-     * Does NOT set stop flag - strategy can continue generating new signals.
-     *
-     * Delegates to StrategyConnectionService.closePending() to clear pending signal
-     * and emit closed event through emitters.
-     * Does not require execution context.
+     * Routes riskRejection event to appropriate ClientAction instance.
      *
+     * @param event - Risk rejection event data
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param context - Context with strategyName, exchangeName, frameName
-     * @param closeId - Optional close ID for user-initiated closes
-     * @returns Promise that resolves when pending signal is closed
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    closePending: (backtest: boolean, symbol: string, context: {
+    riskRejection: (event: RiskContract, backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, closeId?: string) => Promise<void>;
+    }) => Promise<void>;
     /**
-     * Disposes the ClientStrategy instance for the given context.
-     *
-     * Calls dispose on the strategy instance to clean up resources,
-     * then removes it from cache.
+     * Disposes the ClientAction instance for the given action name.
      *
      * @param backtest - Whether running in backtest mode
-     * @param symbol - Trading pair symbol
-     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
      */
-    dispose: (backtest: boolean, symbol: string, context: {
+    dispose: (backtest: boolean, context: {
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
     /**
-     * Clears the memoized ClientStrategy instance from cache.
-     *
-     * Delegates to StrategyConnectionService.dispose() if payload provided,
-     * otherwise clears all strategy instances.
+     * Clears the cached ClientAction instance for the given action name.
      *
-     * @param payload - Optional payload with symbol, context and backtest flag (clears all if not provided)
+     * @param payload - Optional payload with actionName, strategyName, exchangeName, frameName, backtest (clears all if not provided)
      */
     clear: (payload?: {
-        symbol: string;
+        actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
         backtest: boolean;
     }) => Promise<void>;
+}
+
+/**
+ * Type definition for exchange methods.
+ * Maps all keys of IExchange to any type.
+ * Used for dynamic method routing in ExchangeCoreService.
+ */
+type TExchange = {
+    [key in keyof IExchange]: any;
+};
+/**
+ * Global service for exchange operations with execution context injection.
+ *
+ * Wraps ExchangeConnectionService with ExecutionContextService to inject
+ * symbol, when, and backtest parameters into the execution context.
+ *
+ * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
+ */
+declare class ExchangeCoreService implements TExchange {
+    private readonly loggerService;
+    private readonly exchangeConnectionService;
+    private readonly methodContextService;
+    private readonly exchangeValidationService;
     /**
-     * Executes partial close at profit level (moving toward TP).
-     *
-     * Validates strategy existence and delegates to connection service
-     * to close a percentage of the pending position at profit.
-     *
-     * Does not require execution context as this is a direct state mutation.
+     * Validates exchange configuration.
+     * Memoized to avoid redundant validations for the same exchange.
+     * Logs validation activity.
+     * @param exchangeName - Name of the exchange to validate
+     * @returns Promise that resolves when validation is complete
+     */
+    private validate;
+    /**
+     * Fetches historical candles with execution context.
      *
-     * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
-     * @param percentToClose - Percentage of position to close (0-100, absolute value)
-     * @param currentPrice - Current market price for this partial close (must be in profit direction)
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise<boolean> - true if partial close executed, false if skipped
-     *
-     * @example
-     * ```typescript
-     * // Close 30% of position at profit
-     * const success = await strategyCoreService.partialProfit(
-     *   false,
-     *   "BTCUSDT",
-     *   30,
-     *   45000,
-     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
-     * );
-     * if (success) {
-     *   console.log('Partial profit executed');
-     * }
-     * ```
+     * @param interval - Candle interval (e.g., "1m", "1h")
+     * @param limit - Maximum number of candles to fetch
+     * @param when - Timestamp for context (used in backtest mode)
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise resolving to array of candles
      */
-    partialProfit: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<boolean>;
+    getCandles: (symbol: string, interval: CandleInterval, limit: number, when: Date, backtest: boolean) => Promise<ICandleData[]>;
     /**
-     * Executes partial close at loss level (moving toward SL).
-     *
-     * Validates strategy existence and delegates to connection service
-     * to close a percentage of the pending position at loss.
-     *
-     * Does not require execution context as this is a direct state mutation.
+     * Fetches future candles (backtest mode only) with execution context.
      *
-     * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
-     * @param percentToClose - Percentage of position to close (0-100, absolute value)
-     * @param currentPrice - Current market price for this partial close (must be in loss direction)
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise<boolean> - true if partial close executed, false if skipped
-     *
-     * @example
-     * ```typescript
-     * // Close 40% of position at loss
-     * const success = await strategyCoreService.partialLoss(
-     *   false,
-     *   "BTCUSDT",
-     *   40,
-     *   38000,
-     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
-     * );
-     * if (success) {
-     *   console.log('Partial loss executed');
-     * }
-     * ```
+     * @param interval - Candle interval
+     * @param limit - Maximum number of candles to fetch
+     * @param when - Timestamp for context
+     * @param backtest - Whether running in backtest mode (must be true)
+     * @returns Promise resolving to array of future candles
      */
-    partialLoss: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<boolean>;
+    getNextCandles: (symbol: string, interval: CandleInterval, limit: number, when: Date, backtest: boolean) => Promise<ICandleData[]>;
     /**
-     * Adjusts the trailing stop-loss distance for an active pending signal.
-     *
-     * Validates strategy existence and delegates to connection service
-     * to update the stop-loss distance by a percentage adjustment.
-     *
-     * Does not require execution context as this is a direct state mutation.
+     * Calculates VWAP with execution context.
      *
-     * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
-     * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
-     * @param currentPrice - Current market price to check for intrusion
-     * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise that resolves when trailing SL is updated
-     *
-     * @example
-     * ```typescript
-     * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
-     * // Tighten stop by 50%: newSL = 100 - 5% = 95
-     * await strategyCoreService.trailingStop(
-     *   false,
-     *   "BTCUSDT",
-     *   -50,
-     *   102,
-     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
-     * );
-     * ```
+     * @param when - Timestamp for context
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise resolving to VWAP price
      */
-    trailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<boolean>;
+    getAveragePrice: (symbol: string, when: Date, backtest: boolean) => Promise<number>;
     /**
-     * Adjusts the trailing take-profit distance for an active pending signal.
-     * Validates context and delegates to StrategyConnectionService.
+     * Formats price with execution context.
      *
-     * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
-     * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
-     * @param currentPrice - Current market price to check for intrusion
-     * @param context - Strategy context with strategyName, exchangeName, frameName
-     * @returns Promise that resolves when trailing TP is updated
-     *
-     * @example
-     * ```typescript
-     * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
-     * // Move TP further by 50%: newTP = 100 + 15% = 115
-     * await strategyCoreService.trailingTake(
-     *   false,
-     *   "BTCUSDT",
-     *   50,
-     *   102,
-     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
-     * );
-     * ```
+     * @param price - Price to format
+     * @param when - Timestamp for context
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise resolving to formatted price string
      */
-    trailingTake: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<boolean>;
+    formatPrice: (symbol: string, price: number, when: Date, backtest: boolean) => Promise<string>;
     /**
-     * Moves stop-loss to breakeven when price reaches threshold.
-     * Validates context and delegates to StrategyConnectionService.
+     * Formats quantity with execution context.
      *
+     * @param symbol - Trading pair symbol
+     * @param quantity - Quantity to format
+     * @param when - Timestamp for context
      * @param backtest - Whether running in backtest mode
+     * @returns Promise resolving to formatted quantity string
+     */
+    formatQuantity: (symbol: string, quantity: number, when: Date, backtest: boolean) => Promise<string>;
+    /**
+     * Fetches order book with execution context.
+     *
+     * Sets up execution context with the provided when/backtest parameters.
+     * The exchange implementation will receive time range parameters but may
+     * choose to use them (backtest) or ignore them (live).
+     *
      * @param symbol - Trading pair symbol
-     * @param currentPrice - Current market price to check threshold
-     * @param context - Strategy context with strategyName, exchangeName, frameName
-     * @returns Promise<boolean> - true if breakeven was set, false otherwise
+     * @param when - Timestamp for context
+     * @param backtest - Whether running in backtest mode
+     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+     * @returns Promise resolving to order book data
+     */
+    getOrderBook: (symbol: string, when: Date, backtest: boolean, depth?: number) => Promise<IOrderBookData>;
+    /**
+     * Fetches raw candles with flexible date/limit parameters and execution context.
      *
-     * @example
-     * ```typescript
-     * const moved = await strategyCoreService.breakeven(
-     *   false,
-     *   "BTCUSDT",
-     *   112,
-     *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
-     * );
-     * ```
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval (e.g., "1m", "1h")
+     * @param when - Timestamp for context (used in backtest mode)
+     * @param backtest - Whether running in backtest mode
+     * @param limit - Optional number of candles to fetch
+     * @param sDate - Optional start date in milliseconds
+     * @param eDate - Optional end date in milliseconds
+     * @returns Promise resolving to array of candles
      */
-    breakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => Promise<boolean>;
+    getRawCandles: (symbol: string, interval: CandleInterval, when: Date, backtest: boolean, limit?: number, sDate?: number, eDate?: number) => Promise<ICandleData[]>;
 }
 
 /**
@@ -18172,6 +19079,173 @@ declare class RiskReportService {
     unsubscribe: () => Promise<void>;
 }
 
+/**
+ * Service for persisting strategy management events to JSON report files.
+ *
+ * Handles logging of strategy actions (cancel-scheduled, close-pending, partial-profit,
+ * partial-loss, trailing-stop, trailing-take, breakeven) to persistent storage via
+ * the Report class. Each event is written as a separate JSON record.
+ *
+ * Unlike StrategyMarkdownService which accumulates events in memory for markdown reports,
+ * this service writes each event immediately to disk for audit trail purposes.
+ *
+ * Lifecycle:
+ * - Call subscribe() to enable event logging
+ * - Events are written via Report.writeData() with "strategy" category
+ * - Call unsubscribe() to disable event logging
+ *
+ * @example
+ * ```typescript
+ * // Service is typically used internally by strategy management classes
+ * strategyReportService.subscribe();
+ *
+ * // Events are logged automatically when strategy actions occur
+ * await strategyReportService.partialProfit("BTCUSDT", 50, 50100, false, {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1h"
+ * });
+ *
+ * strategyReportService.unsubscribe();
+ * ```
+ *
+ * @see StrategyMarkdownService for in-memory event accumulation and markdown report generation
+ * @see Report for the underlying persistence mechanism
+ */
+declare class StrategyReportService {
+    readonly loggerService: LoggerService;
+    readonly executionContextService: {
+        readonly context: IExecutionContext;
+    };
+    readonly strategyCoreService: StrategyCoreService;
+    /**
+     * Logs a cancel-scheduled event when a scheduled signal is cancelled.
+     *
+     * Retrieves the scheduled signal from StrategyCoreService and writes
+     * the cancellation event to the report file.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param cancelId - Optional identifier for the cancellation reason
+     */
+    cancelScheduled: (symbol: string, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, cancelId?: string) => Promise<void>;
+    /**
+     * Logs a close-pending event when a pending signal is closed.
+     *
+     * Retrieves the pending signal from StrategyCoreService and writes
+     * the close event to the report file.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param closeId - Optional identifier for the close reason
+     */
+    closePending: (symbol: string, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, closeId?: string) => Promise<void>;
+    /**
+     * Logs a partial-profit event when a portion of the position is closed at profit.
+     *
+     * Records the percentage closed and current price when partial profit-taking occurs.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to close (0-100)
+     * @param currentPrice - Current market price at time of partial close
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    partialProfit: (symbol: string, percentToClose: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Logs a partial-loss event when a portion of the position is closed at loss.
+     *
+     * Records the percentage closed and current price when partial loss-cutting occurs.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to close (0-100)
+     * @param currentPrice - Current market price at time of partial close
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    partialLoss: (symbol: string, percentToClose: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Logs a trailing-stop event when the stop-loss is adjusted.
+     *
+     * Records the percentage shift and current price when trailing stop moves.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage the stop-loss was shifted
+     * @param currentPrice - Current market price at time of adjustment
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    trailingStop: (symbol: string, percentShift: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Logs a trailing-take event when the take-profit is adjusted.
+     *
+     * Records the percentage shift and current price when trailing take-profit moves.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage the take-profit was shifted
+     * @param currentPrice - Current market price at time of adjustment
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    trailingTake: (symbol: string, percentShift: number, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Logs a breakeven event when the stop-loss is moved to entry price.
+     *
+     * Records the current price when breakeven protection is activated.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price at time of breakeven activation
+     * @param isBacktest - Whether this is a backtest or live trading event
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     */
+    breakeven: (symbol: string, currentPrice: number, isBacktest: boolean, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Initializes the service for event logging.
+     *
+     * Must be called before any events can be logged. Uses singleshot pattern
+     * to ensure only one subscription exists at a time.
+     *
+     * @returns Cleanup function that clears the subscription when called
+     */
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Stops event logging and cleans up the subscription.
+     *
+     * Safe to call multiple times - only clears if subscription exists.
+     */
+    unsubscribe: () => Promise<void>;
+}
+
 declare const backtest: {
     exchangeValidationService: ExchangeValidationService;
     strategyValidationService: StrategyValidationService;
@@ -18191,6 +19265,7 @@ declare const backtest: {
     partialReportService: PartialReportService;
     breakevenReportService: BreakevenReportService;
     riskReportService: RiskReportService;
+    strategyReportService: StrategyReportService;
     backtestMarkdownService: BacktestMarkdownService;
     liveMarkdownService: LiveMarkdownService;
     scheduleMarkdownService: ScheduleMarkdownService;
@@ -18200,6 +19275,7 @@ declare const backtest: {
     partialMarkdownService: PartialMarkdownService;
     breakevenMarkdownService: BreakevenMarkdownService;
     riskMarkdownService: RiskMarkdownService;
+    strategyMarkdownService: StrategyMarkdownService;
     backtestLogicPublicService: BacktestLogicPublicService;
     liveLogicPublicService: LiveLogicPublicService;
     walkerLogicPublicService: WalkerLogicPublicService;
@@ -18241,4 +19317,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { ActionBase, type ActivePingContract, Backtest, type BacktestDoneNotification, type BacktestStatisticsModel, Breakeven, type BreakevenContract, type BreakevenData, Cache, type CandleData, type CandleInterval, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IBidData, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IMarkdownDumpOptions, type IOrderBookData, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveDoneNotification, type LiveStatisticsModel, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, MethodContextService, type MetricStats, Notification, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossContract, type PartialLossNotification, type PartialProfitContract, type PartialProfitNotification, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, type ProgressBacktestContract, type ProgressBacktestNotification, 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 SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, type TMarkdownBase, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TickEvent, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, 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, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, type ActivePingContract, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Cache, type CandleData, type CandleInterval, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IBidData, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IMarkdownDumpOptions, type IOrderBookData, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, MethodContextService, type MetricStats, Notification, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, 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 SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, Strategy, type StrategyActionType, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, type TMarkdownBase, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TickEvent, type TrailingStopCommitNotification, 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, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, 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, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };