backtest-kit 14.0.0 → 15.0.0

package/types.d.ts

@@ -1122,6 +1122,181 @@ interface SchedulePingContract {
     timestamp: number;
 }
 
+/**
+ * Contract for scheduled signal lifecycle events (creation and cancellation).
+ *
+ * Emitted by scheduleEventSubject when a scheduled signal is created (added) or cancelled
+ * during tick()/backtest() processing. Lets consumers track the scheduled phase of a signal
+ * without subscribing to the full signal stream.
+ *
+ * IMPORTANT: The scheduled -> active transition (activation) is intentionally NOT emitted here.
+ * Activation produces an "opened" signal on the regular signal emitters; this contract only
+ * covers a scheduled signal being put in place and being removed before it ever opened.
+ *
+ * Consumers:
+ * - User callbacks via listenScheduleEvent() / listenScheduleEventOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenScheduleEvent } from "backtest-kit";
+ *
+ * listenScheduleEvent((event) => {
+ *   if (event.action === "scheduled") {
+ *     console.log(`Scheduled ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Cancelled ${event.symbol} (reason: ${event.reason})`);
+ *   }
+ * });
+ * ```
+ */
+interface ScheduleEventContract {
+    /**
+     * Lifecycle action for the scheduled signal.
+     * - "scheduled": a new scheduled signal was created (waiting for priceOpen activation)
+     * - "cancelled": the scheduled signal was removed before activation (timeout / price reject / user)
+     */
+    action: "scheduled" | "cancelled";
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this event belongs to.
+     */
+    symbol: string;
+    /**
+     * Strategy name that owns this scheduled signal.
+     */
+    strategyName: StrategyName;
+    /**
+     * Exchange name where this scheduled signal lives.
+     */
+    exchangeName: ExchangeName;
+    /**
+     * Frame name (timeframe / date range) for the run. Empty string in live mode.
+     * Same value as the signal's `frameName` (`data.frameName`).
+     */
+    frameName: FrameName;
+    /**
+     * Complete scheduled signal row data in public form.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
+     */
+    data: IPublicSignalRow;
+    /**
+     * Cancellation reason. Present only when `action === "cancelled"`:
+     * - "timeout": CC_SCHEDULE_AWAIT_MINUTES elapsed without reaching priceOpen
+     * - "price_reject": price hit stop-loss before activation
+     * - "user": cancelled via cancelScheduled()
+     *
+     * Always undefined when `action === "scheduled"`.
+     */
+    reason?: StrategyCancelReason;
+    /**
+     * Current market price of the symbol at the time of the event.
+     */
+    currentPrice: number;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment of the event
+     * - Backtest mode: candle.timestamp of the candle being processed
+     */
+    timestamp: number;
+}
+
+/**
+ * Contract for pending signal lifecycle events (open and close).
+ *
+ * Emitted by signalEventSubject when a pending position is opened (action "opened") or closed
+ * (action "closed") during tick()/backtest() processing. Lets consumers track the active phase
+ * of a signal without subscribing to the full signal stream.
+ *
+ * Covers every way a position opens (new signal, immediate entry, scheduled activation, user
+ * activation) and every way it closes (take_profit / stop_loss / time_expired / user-close /
+ * broker fill / order no longer pending).
+ *
+ * Consumers:
+ * - User callbacks via listenSignalEvent() / listenSignalEventOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenSignalEvent } from "backtest-kit";
+ *
+ * listenSignalEvent((event) => {
+ *   if (event.action === "opened") {
+ *     console.log(`Opened ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Closed ${event.symbol} (reason: ${event.closeReason})`);
+ *   }
+ * });
+ * ```
+ */
+interface SignalEventContract {
+    /**
+     * Lifecycle action for the pending signal.
+     * - "opened": a pending position was opened (new signal / immediate / scheduled or user activation)
+     * - "closed": the pending position was closed (TP / SL / time_expired / user / broker fill / ping)
+     */
+    action: "opened" | "closed";
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this event belongs to.
+     */
+    symbol: string;
+    /**
+     * Strategy name that owns this pending signal.
+     */
+    strategyName: StrategyName;
+    /**
+     * Exchange name where this pending signal lives.
+     */
+    exchangeName: ExchangeName;
+    /**
+     * Frame name (timeframe / date range) for the run. Empty string in live mode.
+     * Same value as the signal's `frameName` (`data.frameName`).
+     */
+    frameName: FrameName;
+    /**
+     * Complete pending signal row data in public form.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss,
+     * effective entry / trailing SL/TP, PnL, etc.
+     */
+    data: IPublicSignalRow;
+    /**
+     * Close reason. Present only when `action === "closed"`:
+     * - "take_profit": effective take-profit level reached
+     * - "stop_loss": effective stop-loss level reached
+     * - "time_expired": position exceeded minuteEstimatedTime
+     * - "closed": closed by user (closePending) or because the order is no longer open on the exchange
+     *
+     * Always undefined when `action === "opened"`.
+     */
+    closeReason?: StrategyCloseReason;
+    /**
+     * Current market price of the symbol at the time of the event.
+     * For "opened" this is the effective entry (priceOpen); for "closed" the close price.
+     */
+    currentPrice: number;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment of the event
+     * - Backtest mode: candle.timestamp of the candle being processed
+     */
+    timestamp: number;
+}
+
 /**
  * Contract for active ping events during active pending signal monitoring.
  *
@@ -1362,9 +1537,20 @@ interface RiskContract {
 }
 
 /**
- * Base fields shared by all signal sync events.
+ * Base fields shared by all order sync events.
  */
-interface SignalSyncBase {
+interface OrderSyncBase {
+    /**
+     * Which order the sync gate is about:
+     * - "active" — the position order: immediate open, activation fill of a resting
+     *   order, and every close. Reject (false/throw) skips the open/close; a rejected
+     *   fresh open rolls back the interval throttle and retries on the next tick.
+     * - "schedule" — the resting entry order being PLACED when a scheduled signal is
+     *   created (action "signal-open" only). Reject means the exchange did not accept
+     *   the resting order: the scheduled signal is NOT registered, the risk
+     *   reservation is released and the placement retries on the next tick.
+     */
+    type: "schedule" | "active";
     /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
     /** Strategy name that generated this signal */
@@ -1398,7 +1584,7 @@ interface SignalSyncBase {
  * - External order sync services
  * - Audit/logging pipelines
  */
-interface SignalOpenContract extends SignalSyncBase {
+interface OrderOpenContract extends OrderSyncBase {
     /** Discriminator for signal-open action */
     action: "signal-open";
     /** Market price at the moment of activation (VWAP or candle average) */
@@ -1453,7 +1639,7 @@ interface SignalOpenContract extends SignalSyncBase {
  * - External order sync services
  * - Audit/logging pipelines
  */
-interface SignalCloseContract extends SignalSyncBase {
+interface OrderCloseContract extends OrderSyncBase {
     /** Discriminator for signal-close action */
     action: "signal-close";
     /** Market price at the moment of close */
@@ -1496,37 +1682,48 @@ interface SignalCloseContract extends SignalSyncBase {
     totalPartials: number;
 }
 /**
- * Discriminated union for signal sync events.
+ * Discriminated union for order sync events.
  *
  * Emitted to allow external systems to synchronize with the framework's
- * limit order lifecycle: open (limit filled) and close (position exited).
+ * order lifecycle: open (type "active" — immediate/activation fill; type
+ * "schedule" — placement of the resting entry order at scheduled-signal
+ * creation) and close (position exited, always type "active").
  *
- * Note: Only covers the scheduled → pending → closed lifecycle.
- * Signals that were never activated (cancelled scheduled signals) do NOT emit SignalOpenContract.
+ * Note: cancelled scheduled signals do NOT emit OrderOpenContract — their
+ * teardown goes through the schedule-event channel (Broker.commitScheduleCancelled).
  */
-type SignalSyncContract = SignalOpenContract | SignalCloseContract;
+type OrderSyncContract = OrderOpenContract | OrderCloseContract;
 
 /**
- * Signal pending-ping sync event.
+ * Signal order-ping sync event.
  *
- * Emitted on every live tick while a pending signal (open position) is being monitored,
- * BEFORE the framework evaluates TP/SL/time completion. It asks the external order
- * management system whether the corresponding order is STILL pending (open) on the exchange.
+ * Emitted on every live tick while a signal is being monitored, BEFORE the framework
+ * evaluates completion. It asks the external order management system whether the
+ * corresponding order is STILL open on the exchange. Fires for BOTH monitored states,
+ * discriminated by `type`:
+ * - `type: "active"` — a pending signal (open position); the order backing the position.
+ * - `type: "schedule"` — a scheduled signal; the resting entry order awaiting activation.
  *
  * Listener contract (mirrors syncSubject semantics):
  * - Return true (or do nothing) — the order is still open on the exchange, keep monitoring.
  * - Return false OR throw — the order is no longer open on the exchange (filled, cancelled,
- *   liquidated externally). The framework closes the pending signal with closeReason "closed".
+ *   liquidated externally). For "active" the framework closes the pending signal with
+ *   closeReason "closed"; for "schedule" it cancels the scheduled signal (reason "user").
+ *   NOTE for "schedule": if the resting order actually FILLED, confirm it via
+ *   activateScheduled/commitActivateScheduled instead of failing the ping — a failed ping
+ *   is a terminal cancel, not an activation.
  *
  * Backtest never emits this event — there is no live exchange to query.
  *
  * Consumers:
- * - Broker adapter via `onOrderPing` (syncPendingSubject subscription)
- * - Registered actions via `orderPing` / `onOrderPing`
+ * - Broker adapter via `onOrderActiveCheck` / `onOrderScheduleCheck` (syncPendingSubject subscription)
+ * - Registered actions via `orderCheck` / `onOrderCheck`
  */
-interface SignalPingContract {
+interface OrderCheckContract {
     /** Discriminator for pending-ping action */
     action: "signal-ping";
+    /** Monitored state: "active" — open position order, "schedule" — resting entry order */
+    type: "schedule" | "active";
     /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
     /** Strategy name that generated this signal */
@@ -1834,6 +2031,96 @@ interface IActionCallbacks {
      * @param backtest - True for backtest mode, false for live trading
      */
     onPingScheduled(event: SchedulePingContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    /**
+     * Called on scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Triggered by: StrategyConnectionService via scheduleEventSubject
+     * Frequency: Once on creation (action "scheduled") and once on cancellation before activation
+     * (action "cancelled": timeout / price_reject / user). The scheduled -> active transition is
+     * NOT reported here — activation surfaces as an "opened" signal instead.
+     *
+     * Manual wiring — EVENT-BASED (driving the exchange from an action registered via `addActionSchema`)
+     *
+     * An action is the alternative to a Broker adapter for binding the framework to a real exchange:
+     * both run inside the strategy tick, so the commit-functions from `src/function/strategy.ts` are
+     * callable here and take effect on the next tick. On `event.action === "scheduled"` place the real
+     * resting/limit order (tag it with `event.data.id`) and, if it resolves at once, call
+     * `commitActivateScheduled(event.symbol, { id })`; on a reject call
+     * `commitCancelScheduled(event.symbol, { id })`. On `event.action === "cancelled"` (the strategy has
+     * already dropped the scheduled signal) cancel the matching exchange order; `event.reason` says why.
+     * For ongoing polling of the resting order use `onPingScheduled` (every tick).
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     * @param actionName - Action identifier
+     * @param strategyName - Strategy identifier
+     * @param frameName - Timeframe identifier
+     * @param backtest - True for backtest mode, false for live trading
+     *
+     * @example
+     * ```typescript
+     * import { addActionSchema, commitActivateScheduled, commitCancelScheduled } from "backtest-kit";
+     *
+     * addActionSchema({
+     *   actionName: "exchange-bridge",
+     *   callbacks: {
+     *     async onScheduleEvent(event) {
+     *       if (event.action === "scheduled") {
+     *         const order = await exchange.placeLimit(event.symbol, event.data.priceOpen, event.data.id);
+     *         if (order.status === "filled") await commitActivateScheduled(event.symbol, { id: order.id });
+     *       } else {
+     *         await exchange.cancelOrderById(event.data.id);
+     *       }
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    onScheduleEvent(event: ScheduleEventContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    /**
+     * Called on pending signal lifecycle events (open / close).
+     *
+     * Triggered by: StrategyConnectionService via signalEventSubject
+     * Frequency: Once when a pending position is opened (action "opened": new signal / immediate /
+     * scheduled or user activation) and once when it is closed (action "closed" with closeReason
+     * take_profit / stop_loss / time_expired / closed).
+     *
+     * Manual wiring — EVENT-BASED (driving the exchange from an action registered via `addActionSchema`)
+     *
+     * Alternative to a Broker adapter — the commit-functions from `src/function/strategy.ts` are
+     * callable here (same tick context) and apply on the next tick. On `event.action === "opened"`
+     * place the real entry + protective TP/SL orders; on `event.action === "closed"` (the strategy has
+     * already removed the signal) flatten the real position and cancel leftover orders.
+     *
+     * Note: `onPendingEvent` fires only at open/close — it is NOT a per-tick monitor. To translate
+     * intra-position exchange fills into `commitCreateTakeProfit` / `commitCreateStopLoss` /
+     * `commitClosePending` on every tick, use `onPingActive` (fires each tick while the position is open).
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     * @param actionName - Action identifier
+     * @param strategyName - Strategy identifier
+     * @param frameName - Timeframe identifier
+     * @param backtest - True for backtest mode, false for live trading
+     *
+     * @example
+     * ```typescript
+     * import { addActionSchema, commitClosePending } from "backtest-kit";
+     *
+     * addActionSchema({
+     *   actionName: "exchange-bridge",
+     *   callbacks: {
+     *     async onPendingEvent(event) {
+     *       if (event.action === "opened") await exchange.openWithProtection(event.symbol, event.data);
+     *       else await exchange.flatten(event.symbol, event.data.id);
+     *     },
+     *     async onPingActive(event) { // per-tick fills -> close
+     *       const order = await exchange.getOrderById(event.data.id);
+     *       if (order?.status === "no_counterparty") await commitClosePending(event.symbol, { id: order.id });
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    onPendingEvent(event: SignalEventContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
     /**
      * Called during active pending signal monitoring (every minute while position is active).
      *
@@ -1881,37 +2168,54 @@ interface IActionCallbacks {
      * They propagate up to CREATE_SYNC_FN which catches them and returns false.
      * Throw to reject the operation — framework will retry on next tick.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: the action-side equivalent of the Broker
+     * `onOrderOpenCommit` / `onOrderCloseCommit` gate. Throwing (or returning false) on
+     * `event.action === "signal-open"` rolls the open back to idle (a scheduled activation is
+     * cancelled); on `"signal-close"` it skips the close and leaves the position open — retried next
+     * tick. Rides the same `syncSubject` emission as the Broker commit hooks, so a throw from either is
+     * collapsed to false by `CREATE_SYNC_FN`. Backtest short-circuits the gate to true (live-only).
+     *
      * @param event - Sync event with action "signal-open" or "signal-close"
      * @param actionName - Action identifier
      * @param strategyName - Strategy identifier
      * @param frameName - Timeframe identifier
      * @param backtest - True for backtest mode, false for live trading
      */
-    onSignalSync(event: SignalSyncContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    onOrderSync(event: OrderSyncContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
     /**
      * Called on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation,
      * to confirm the order is still pending (open) on the exchange.
      *
+     * Fires for both monitored states, discriminated by `event.type`: "active" — pending signal
+     * (open position); "schedule" — scheduled signal (resting entry order awaiting activation).
+     *
      * Query the exchange by `event.signalId` and THROW ONLY when the order is NOT FOUND by that id
      * (filled, cancelled, or liquidated externally) — the framework then closes the position with
-     * closeReason "closed".
+     * closeReason "closed" (type "active") or cancels the scheduled signal with reason "user"
+     * (type "schedule").
      *
      * CRITICAL: swallow transient/network errors (timeout, 5xx, rate limit, disconnect) — return
      * normally instead of throwing, otherwise a connectivity blip would wrongly close an open
      * position. Throw exclusively on a confirmed "order not found by id" result.
      *
-     * NOTE: Like onSignalSync, exceptions from this method are NOT swallowed. They propagate up to
+     * NOTE: Like onOrderSync, exceptions from this method are NOT swallowed. They propagate up to
      * CREATE_SYNC_PENDING_FN which catches them and returns false.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: the action-side equivalent of the Broker `onOrderCheck`.
+     * A THROW on a confirmed "order not found by id" closes the position with closeReason "closed"
+     * (retried via CREATE_SYNC_PENDING_FN). This is the throw-driven alternative to the imperative
+     * `commitClosePending` (call it from `pingActive` instead) — pick one, not both, for the same
+     * "order gone" condition. Backtest short-circuits the gate (live-only).
+     *
      * @deprecated This callback is not recommended for use. Exchange integration should be implemented
-     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderPing instead.
+     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderCheck instead.
      * @param event - Pending-ping event with action "signal-ping"
      * @param actionName - Action identifier
      * @param strategyName - Strategy identifier
      * @param frameName - Timeframe identifier
      * @param backtest - True for backtest mode, false for live trading
      */
-    onOrderPing(event: SignalPingContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    onOrderCheck(event: OrderCheckContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
 }
 /**
  * Action schema registered via addActionSchema().
@@ -2142,6 +2446,35 @@ interface IAction {
      * @param event - Scheduled signal monitoring data
      */
     pingScheduled(event: SchedulePingContract): void | Promise<void>;
+    /**
+     * Handles scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Emitted by: StrategyConnectionService via scheduleEventSubject
+     * Source: CREATE_COMMIT_SCHEDULE_EVENT_FN callback in StrategyConnectionService
+     * Frequency: Once when a scheduled signal is created ("scheduled") and once when it is
+     * cancelled before activation ("cancelled": timeout / price_reject / user). The
+     * scheduled -> active transition is NOT reported here.
+     *
+     * Manual wiring — EVENT-BASED: implement the user-facing callback {@link IActionCallbacks.onScheduleEvent} (via
+     * `addActionSchema`) to drive the exchange (`commitActivateScheduled` / `commitCancelScheduled`).
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     */
+    scheduleEvent(event: ScheduleEventContract): void | Promise<void>;
+    /**
+     * Handles pending signal lifecycle events (open / close).
+     *
+     * Emitted by: StrategyConnectionService via signalEventSubject
+     * Source: CREATE_COMMIT_SIGNAL_EVENT_FN callback in StrategyConnectionService
+     * Frequency: Once when a pending position is opened (action "opened") and once when it is
+     * closed (action "closed" with closeReason take_profit / stop_loss / time_expired / closed).
+     *
+     * Manual wiring — EVENT-BASED: implement the user-facing callback {@link IActionCallbacks.onPendingEvent} (via
+     * `addActionSchema`) to drive the exchange; for per-tick fills use `onPingActive`.
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     */
+    pendingEvent(event: SignalEventContract): void | Promise<void>;
     /**
      * Handles active ping events during active pending signal monitoring.
      *
@@ -2178,12 +2511,18 @@ interface IAction {
      *
      * NOTE: Exceptions are NOT swallowed here — they propagate to CREATE_SYNC_FN.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: action-side equivalent of the Broker
+     * `onOrderOpenCommit` / `onOrderCloseCommit`. Throw on "signal-open" → open rolls back to idle
+     * (scheduled activation cancelled); throw on "signal-close" → close skipped, position stays open;
+     * retried next tick. Same `syncSubject` emission as the Broker commit hooks (collapsed to false by
+     * CREATE_SYNC_FN). Live-only. Implement via the {@link IActionCallbacks.onOrderSync} callback.
+     *
      * @deprecated This method is not recommended for use. Implement custom logic in signal(), signalLive(), or signalBacktest() instead.
      * If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() instead.
-     * If Action::signalSync throws the exchange will not execute the order!
+     * If Action::orderSync throws the exchange will not execute the order!
      * @param event - Sync event with action "signal-open" or "signal-close"
      */
-    signalSync(event: SignalSyncContract): void | Promise<void>;
+    orderSync(event: OrderSyncContract): void | Promise<void>;
     /**
      * Called on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation,
      * to confirm the order is still pending (open) on the exchange.
@@ -2198,12 +2537,19 @@ interface IAction {
      *
      * NOTE: Exceptions are NOT swallowed here — they propagate to CREATE_SYNC_PENDING_FN.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: action-side equivalent of the Broker `onOrderCheck`. A
+     * throw on a confirmed "order not found by id" closes the position with closeReason "closed"
+     * (retried via CREATE_SYNC_PENDING_FN). Throw-driven alternative to the imperative
+     * `commitClosePending` (call it from `pingActive`) — pick one, not both. Live-only. Implement via
+     * the {@link IActionCallbacks.onOrderCheck} callback.
+     *
      * @deprecated This method is not recommended for use. Exchange integration should be implemented
-     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderPing instead.
-     * If Action::orderPing throws the framework will close the position with closeReason "closed"!
-     * @param event - Pending-ping event with action "signal-ping"
+     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderCheck instead.
+     * If Action::orderCheck throws the framework will close the position with closeReason "closed"
+     * (event.type "active") or cancel the scheduled signal (event.type "schedule")!
+     * @param event - Order-ping event with action "signal-ping" and type "schedule" | "active"
      */
-    orderPing(event: SignalPingContract): void | Promise<void>;
+    orderCheck(event: OrderCheckContract): void | Promise<void>;
     /**
      * Cleans up resources and subscriptions when action handler is no longer needed.
      *
@@ -2564,6 +2910,20 @@ type StrategyStatus = {
     cancelledSignal: IScheduledSignalCancelRow | null;
     /** Deferred user-initiated scheduled activate (activateScheduled), or null if none pending */
     activatedSignal: IScheduledSignalActivateRow | null;
+    /**
+     * Deferred broker-confirmed take-profit fill (createTakeProfit), or null if none pending.
+     * Set when the external order management system reports the position's TP order was actually
+     * filled on the exchange (e.g. by candle high/low) — independent of the VWAP-based TP check.
+     * Drained on the next tick/backtest to close the position with closeReason "take_profit".
+     */
+    takeProfitSignal: ISignalCloseRow | null;
+    /**
+     * Deferred broker-confirmed stop-loss fill (createStopLoss), or null if none pending.
+     * Set when the external order management system reports the position's SL order was actually
+     * filled on the exchange (e.g. by candle high/low) — independent of the VWAP-based SL check.
+     * Drained on the next tick/backtest to close the position with closeReason "stop_loss".
+     */
+    stopLossSignal: ISignalCloseRow | null;
 };
 /**
  * Commit payload for strategy commits.
@@ -3584,6 +3944,44 @@ interface IStrategy {
      * @returns Promise that resolves when the DTO is queued
      */
     createSignal: (symbol: string, currentPrice: number, dto: ISignalDto) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that does not wait for the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against
+     * VWAP, but the real order may close on high/low. This method bridges that gap — the broker
+     * confirms the fill out of the async-hooks execution context, and the close is deferred:
+     * a snapshot of the current pending signal is stored and drained on the next tick/backtest,
+     * which closes the position with closeReason "take_profit" at the effective take-profit level.
+     *
+     * No-op if no pending signal exists. Persisted (live mode only) so a crash before the next
+     * tick does not lose the deferred close.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param payload - Optional commit id/note attached to the close
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    createTakeProfit: (symbol: string, backtest: boolean, payload: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that does not wait for the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against
+     * VWAP, but the real order may close on high/low. This method bridges that gap — the broker
+     * confirms the fill out of the async-hooks execution context, and the close is deferred:
+     * a snapshot of the current pending signal is stored and drained on the next tick/backtest,
+     * which closes the position with closeReason "stop_loss" at the effective stop-loss level.
+     *
+     * No-op if no pending signal exists. Persisted (live mode only) so a crash before the next
+     * tick does not lose the deferred close.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param payload - Optional commit id/note attached to the close
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    createStopLoss: (symbol: string, backtest: boolean, payload: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the deferred strategy-state snapshot held in memory for this iteration — exactly
      * what would be written to persist (queued createSignal, commit queue, deferred user-action
@@ -5722,6 +6120,9 @@ declare function commitAverageBuy(symbol: string, cost?: number): Promise<boolea
  *
  * Automatically detects backtest/live mode from execution context.
  *
+ * @deprecated The name is misleading — the function returns the HELD share,
+ * not the closed one. Use {@link getTotalPercentHeld} instead.
+ *
  * @param symbol - Trading pair symbol
  * @returns Promise<number> - held percentage (0–100)
  *
@@ -5740,6 +6141,9 @@ declare function getTotalPercentClosed(symbol: string): Promise<number>;
  *
  * Automatically detects backtest/live mode from execution context.
  *
+ * @deprecated The name is misleading — the function returns the REMAINING
+ * cost basis, not the closed one. Use {@link getRemainingCostBasis} instead.
+ *
  * @param symbol - Trading pair symbol
  * @returns Promise<number> - held cost basis in dollars
  *
@@ -5752,6 +6156,44 @@ declare function getTotalPercentClosed(symbol: string): Promise<number>;
  * ```
  */
 declare function getTotalCostClosed(symbol: string): Promise<number>;
+/**
+ * Returns the percentage of the position currently held (not yet closed by partials).
+ * 100 = nothing has been closed (full position), 0 = fully closed.
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Correctly-named alias for {@link getTotalPercentClosed}.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held percentage (0–100)
+ *
+ * @example
+ * ```typescript
+ * import { getTotalPercentHeld } from "backtest-kit";
+ *
+ * const heldPct = await getTotalPercentHeld("BTCUSDT");
+ * console.log(`Holding ${heldPct}% of position`);
+ * ```
+ */
+declare function getTotalPercentHeld(symbol: string): Promise<number>;
+/**
+ * Returns the remaining cost basis in dollars — how much of the position is
+ * still held (not yet closed by partials). Correctly accounts for DCA entries
+ * between partial closes.
+ *
+ * Correctly-named alias for {@link getTotalCostClosed}.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - remaining cost basis in dollars
+ *
+ * @example
+ * ```typescript
+ * import { getRemainingCostBasis } from "backtest-kit";
+ *
+ * const remaining = await getRemainingCostBasis("BTCUSDT");
+ * console.log(`Holding $${remaining} of position`);
+ * ```
+ */
+declare function getRemainingCostBasis(symbol: string): Promise<number>;
 /**
  * Returns the currently active pending signal for the strategy.
  * If no active signal exists, returns null.
@@ -6635,6 +7077,52 @@ declare function commitSignalNotify(symbol: string, payload?: Partial<SignalNoti
  * ```
  */
 declare function commitCreateSignal(symbol: string, dto: ISignalDto): Promise<void>;
+/**
+ * Reports that the pending position's take-profit order was actually filled on the exchange
+ * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+ *
+ * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+ * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+ * "take_profit" on the next tick. No-op if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param payload - Optional commit payload with id and note
+ * @returns Promise that resolves when the take-profit fill is queued
+ *
+ * @example
+ * ```typescript
+ * import { commitCreateTakeProfit } from "backtest-kit";
+ *
+ * // Report TP fill confirmed on the exchange
+ * await commitCreateTakeProfit("BTCUSDT", { id: "tp-fill-001" });
+ * ```
+ */
+declare function commitCreateTakeProfit(symbol: string, payload?: Partial<CommitPayload>): Promise<void>;
+/**
+ * Reports that the pending position's stop-loss order was actually filled on the exchange
+ * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+ *
+ * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+ * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+ * "stop_loss" on the next tick. No-op if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param payload - Optional commit payload with id and note
+ * @returns Promise that resolves when the stop-loss fill is queued
+ *
+ * @example
+ * ```typescript
+ * import { commitCreateStopLoss } from "backtest-kit";
+ *
+ * // Report SL fill confirmed on the exchange
+ * await commitCreateStopLoss("BTCUSDT", { id: "sl-fill-001" });
+ * ```
+ */
+declare function commitCreateStopLoss(symbol: string, payload?: Partial<CommitPayload>): Promise<void>;
 /**
  * Returns the in-memory deferred strategy-state snapshot for the current iteration: the queued
  * createSignal, commit queue and deferred user-action flags, plus the current pending signal id.
@@ -6663,16 +7151,15 @@ declare function getStrategyStatus(symbol: string): Promise<StrategyStatus>;
  *
  * Automatically detects backtest/live mode from execution context.
  *
- * @param symbol - Trading pair symbol
- * @param strategyName - Strategy name to stop
+ * @param symbol - Trading pair symbol; the strategy is resolved from the active method context
  * @returns Promise that resolves when stop flag is set
  *
  * @example
  * ```typescript
- * import { stop } from "backtest-kit";
+ * import { stopStrategy } from "backtest-kit";
  *
- * // Stop strategy after some condition
- * await stop("BTCUSDT", "my-strategy");
+ * // Stop strategy after some condition (inside a strategy/action callback)
+ * await stopStrategy("BTCUSDT");
  * ```
  */
 declare function stopStrategy(symbol: string): Promise<void>;
@@ -9248,9 +9735,9 @@ declare function listenValidation(fn: (error: Error) => void): () => void;
  *
  * @example
  * ```typescript
- * import { listenPartialProfit } from "./function/event";
+ * import { listenPartialProfitAvailable } from "./function/event";
  *
- * const unsubscribe = listenPartialProfit((event) => {
+ * const unsubscribe = listenPartialProfitAvailable((event) => {
  *   console.log(`Signal ${event.data.id} reached ${event.level}% profit`);
  *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
  *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
@@ -9304,9 +9791,9 @@ declare function listenPartialProfitAvailableOnce(filterFn: (event: PartialProfi
  *
  * @example
  * ```typescript
- * import { listenPartialLoss } from "./function/event";
+ * import { listenPartialLossAvailable } from "./function/event";
  *
- * const unsubscribe = listenPartialLoss((event) => {
+ * const unsubscribe = listenPartialLossAvailable((event) => {
  *   console.log(`Signal ${event.data.id} reached ${event.level}% loss`);
  *   console.log(`Symbol: ${event.symbol}, Price: ${event.currentPrice}`);
  *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
@@ -9361,9 +9848,9 @@ declare function listenPartialLossAvailableOnce(filterFn: (event: PartialLossCon
  *
  * @example
  * ```typescript
- * import { listenBreakeven } from "./function/event";
+ * import { listenBreakevenAvailable } from "./function/event";
  *
- * const unsubscribe = listenBreakeven((event) => {
+ * const unsubscribe = listenBreakevenAvailable((event) => {
  *   console.log(`Signal ${event.data.id} reached breakeven`);
  *   console.log(`Symbol: ${event.symbol}, Position: ${event.data.position}`);
  *   console.log(`Entry: ${event.data.priceOpen}, Current: ${event.currentPrice}`);
@@ -9524,6 +10011,111 @@ declare function listenSchedulePing(fn: (event: SchedulePingContract) => void):
  * ```
  */
 declare function listenSchedulePingOnce(filterFn: (event: SchedulePingContract) => boolean, fn: (event: SchedulePingContract) => void): () => void;
+/**
+ * Subscribes to scheduled signal lifecycle events (creation and cancellation) with queued async processing.
+ *
+ * Emitted when a scheduled signal is created (action "scheduled") or cancelled before activation
+ * (action "cancelled" with reason "timeout" / "price_reject" / "user"), in both live and backtest.
+ *
+ * IMPORTANT: The scheduled -> active transition (activation) is NOT reported here. Activation
+ * produces an "opened" event on the regular signal emitters (listenSignal) instead.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ *
+ * @param fn - Callback function to handle scheduled lifecycle events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenScheduleEvent } from "./function/event";
+ *
+ * const unsubscribe = listenScheduleEvent((event) => {
+ *   if (event.action === "scheduled") {
+ *     console.log(`Scheduled ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Cancelled ${event.symbol} (reason: ${event.reason})`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenScheduleEvent(fn: (event: ScheduleEventContract) => void): () => void;
+/**
+ * Subscribes to filtered scheduled lifecycle events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for a specific scheduled creation
+ * or cancellation.
+ *
+ * @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 { listenScheduleEventOnce } from "./function/event";
+ *
+ * // Wait for the first cancellation on BTCUSDT
+ * listenScheduleEventOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.action === "cancelled",
+ *   (event) => console.log("BTCUSDT scheduled cancelled:", event.reason)
+ * );
+ * ```
+ */
+declare function listenScheduleEventOnce(filterFn: (event: ScheduleEventContract) => boolean, fn: (event: ScheduleEventContract) => void): () => void;
+/**
+ * Subscribes to pending signal lifecycle events (open and close) with queued async processing.
+ *
+ * Emitted when a pending position is opened (action "opened": new signal / immediate / scheduled
+ * or user activation) or closed (action "closed" with closeReason "take_profit" / "stop_loss" /
+ * "time_expired" / "closed"), in both live and backtest.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ *
+ * @param fn - Callback function to handle pending lifecycle events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenSignalEvent } from "./function/event";
+ *
+ * const unsubscribe = listenSignalEvent((event) => {
+ *   if (event.action === "opened") {
+ *     console.log(`Opened ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Closed ${event.symbol} (reason: ${event.closeReason})`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenSignalEvent(fn: (event: SignalEventContract) => void): () => void;
+/**
+ * Subscribes to filtered pending lifecycle events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for a specific open or close.
+ *
+ * @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 { listenSignalEventOnce } from "./function/event";
+ *
+ * // Wait for the first close on BTCUSDT
+ * listenSignalEventOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.action === "closed",
+ *   (event) => console.log("BTCUSDT closed:", event.closeReason)
+ * );
+ * ```
+ */
+declare function listenSignalEventOnce(filterFn: (event: SignalEventContract) => boolean, fn: (event: SignalEventContract) => void): () => void;
 /**
  * Subscribes to active ping events with queued async processing.
  *
@@ -9675,7 +10267,7 @@ declare function listenStrategyCommitOnce(filterFn: (event: StrategyCommitContra
  * @param fn - Callback function to handle sync events. If the function returns a promise, signal processing will wait until it resolves.
  * @returns Unsubscribe function to stop listening
  */
-declare function listenSync(fn: (event: SignalSyncContract) => void, warned?: boolean): () => void;
+declare function listenSync(fn: (event: OrderSyncContract) => void, warned?: boolean): () => void;
 /**
  * Subscribes to filtered signal synchronization events with one-time execution.
  * If throws position is not being opened/closed until the async function completes. Useful for synchronizing with external systems.
@@ -9684,7 +10276,30 @@ declare function listenSync(fn: (event: SignalSyncContract) => void, warned?: bo
  * @param fn - Callback function to handle the filtered event (called only once). If the function returns a promise, signal processing will wait until it resolves.
  * @returns Unsubscribe function to cancel the listener before it fires
  */
-declare function listenSyncOnce(filterFn: (event: SignalSyncContract) => boolean, fn: (event: SignalSyncContract) => void, warned?: boolean): () => void;
+declare function listenSyncOnce(filterFn: (event: OrderSyncContract) => boolean, fn: (event: OrderSyncContract) => void, warned?: boolean): () => void;
+/**
+ * Subscribes to order-check ping events with queued async processing.
+ * If throws, the order behind the monitored signal is treated as no longer open on the
+ * exchange until the async function completes. Useful for synchronizing with external systems.
+ *
+ * Emits on every live tick while a signal is monitored, BEFORE completion evaluation,
+ * discriminated by `event.type`: "active" — pending signal (open position), "schedule" —
+ * scheduled signal (resting entry order). Backtest never emits this event.
+ *
+ * @param fn - Callback function to handle check events. If the function returns a promise, signal processing will wait until it resolves.
+ * @returns Unsubscribe function to stop listening
+ */
+declare function listenCheck(fn: (event: OrderCheckContract) => void, warned?: boolean): () => void;
+/**
+ * Subscribes to filtered order-check ping events with one-time execution.
+ * If throws, the order behind the monitored signal is treated as no longer open on the
+ * exchange until the async function completes. Useful for synchronizing with external systems.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once). If the function returns a promise, signal processing will wait until it resolves.
+ * @returns Unsubscribe function to cancel the listener before it fires
+ */
+declare function listenCheckOnce(filterFn: (event: OrderCheckContract) => boolean, fn: (event: OrderCheckContract) => void, warned?: boolean): () => void;
 /**
  * Subscribes to highest profit events with queued async processing.
  * Emits when a signal reaches a new highest profit level during its lifecycle.
@@ -10166,8 +10781,8 @@ declare function getMinutesSinceLatestSignalCreated(symbol: string): Promise<num
 /**
  * Reads the state value scoped to the current active signal.
  *
- * Resolves the active pending signal automatically from execution context.
- * If no pending signal exists, logs a warning and returns the initialValue.
+ * Resolves the active pending or scheduled signal automatically from execution context.
+ * Throws if neither a pending nor a scheduled signal exists.
  *
  * Automatically detects backtest/live mode from execution context.
  *
@@ -10204,8 +10819,8 @@ declare function getSignalState<Value extends object = object>(symbol: string, d
 /**
  * Updates the state value scoped to the current active signal.
  *
- * Resolves the active pending signal automatically from execution context.
- * If no pending signal exists, logs a warning and returns without writing.
+ * Resolves the active pending or scheduled signal automatically from execution context.
+ * Throws if neither a pending nor a scheduled signal exists.
  *
  * Automatically detects backtest/live mode from execution context.
  *
@@ -12220,7 +12835,7 @@ interface TrailingTakeCommitNotification {
  * Signal sync open notification.
  * Emitted when a scheduled (limit order) signal is activated and the position is opened.
  */
-interface SignalSyncOpenNotification {
+interface OrderSyncOpenNotification {
     /** Discriminator for type-safe union */
     type: "signal_sync.open";
     /** Unique notification identifier */
@@ -12308,7 +12923,7 @@ interface SignalSyncOpenNotification {
  * Signal sync close notification.
  * Emitted when an active pending signal is closed (TP/SL hit, time expired, or user-initiated).
  */
-interface SignalSyncCloseNotification {
+interface OrderSyncCloseNotification {
     /** Discriminator for type-safe union */
     type: "signal_sync.close";
     /** Unique notification identifier */
@@ -12878,7 +13493,7 @@ interface SignalInfoNotification {
  * }
  * ```
  */
-type NotificationModel = SignalOpenedNotification | SignalClosedNotification | PartialProfitAvailableNotification | PartialLossAvailableNotification | BreakevenAvailableNotification | PartialProfitCommitNotification | PartialLossCommitNotification | BreakevenCommitNotification | AverageBuyCommitNotification | ActivateScheduledCommitNotification | TrailingStopCommitNotification | TrailingTakeCommitNotification | CancelScheduledCommitNotification | ClosePendingCommitNotification | SignalSyncOpenNotification | SignalSyncCloseNotification | RiskRejectionNotification | SignalScheduledNotification | SignalCancelledNotification | InfoErrorNotification | CriticalErrorNotification | ValidationErrorNotification | SignalInfoNotification;
+type NotificationModel = SignalOpenedNotification | SignalClosedNotification | PartialProfitAvailableNotification | PartialLossAvailableNotification | BreakevenAvailableNotification | PartialProfitCommitNotification | PartialLossCommitNotification | BreakevenCommitNotification | AverageBuyCommitNotification | ActivateScheduledCommitNotification | TrailingStopCommitNotification | TrailingTakeCommitNotification | CancelScheduledCommitNotification | ClosePendingCommitNotification | OrderSyncOpenNotification | OrderSyncCloseNotification | RiskRejectionNotification | SignalScheduledNotification | SignalCancelledNotification | InfoErrorNotification | CriticalErrorNotification | ValidationErrorNotification | SignalInfoNotification;
 
 /**
  * Unified tick event data for report generation.
@@ -14350,6 +14965,18 @@ type StrategyData = {
     cancelledSignal: IScheduledSignalCancelRow | null;
     /** Deferred user-initiated scheduled activate (activateScheduled), or null if none pending */
     activatedSignal: IScheduledSignalActivateRow | null;
+    /**
+     * Deferred broker-confirmed take-profit fill (createTakeProfit), or null if none pending.
+     * Set when the exchange reports the TP order was actually filled (e.g. by candle high/low),
+     * independent of the VWAP-based TP check. Drained on the next tick to close with "take_profit".
+     */
+    takeProfitSignal: ISignalCloseRow | null;
+    /**
+     * Deferred broker-confirmed stop-loss fill (createStopLoss), or null if none pending.
+     * Set when the exchange reports the SL order was actually filled (e.g. by candle high/low),
+     * independent of the VWAP-based SL check. Drained on the next tick to close with "stop_loss".
+     */
+    stopLossSignal: ISignalCloseRow | null;
 };
 /**
  * Per-context deferred strategy state persistence instance interface.
@@ -16106,6 +16733,8 @@ declare class PersistMemoryInstance implements IPersistMemoryInstance {
     writeMemoryData(data: MemoryData, memoryId: string, _when: Date): Promise<void>;
     /**
      * Soft-deletes a memory entry by writing `removed: true` flag.
+     * No-op when the entry does not exist (readValue throws on a missing
+     * entity, so existence must be checked first to keep removal idempotent).
      *
      * @param memoryId - Memory entry identifier
      * @returns Promise that resolves when removal is complete
@@ -16702,16 +17331,27 @@ declare class PersistSessionInstance implements IPersistSessionInstance {
     readonly strategyName: string;
     readonly exchangeName: string;
     readonly frameName: string;
+    readonly symbol: string;
+    readonly backtest: boolean;
     /** Underlying file-based storage scoped to this context */
     private readonly _storage;
+    /**
+     * Entity key inside the per-strategy/exchange/frame storage directory.
+     * Includes the symbol and backtest flag: without them two symbols running
+     * the same strategy would clobber one shared record and restore each
+     * other's session state after a restart.
+     */
+    private readonly _entityId;
     /**
      * Creates new session persistence instance.
      *
      * @param strategyName - Strategy identifier
      * @param exchangeName - Exchange identifier
-     * @param frameName - Frame identifier (also used as entity ID)
+     * @param frameName - Frame identifier (storage subdirectory)
+     * @param symbol - Trading pair symbol (part of the entity key)
+     * @param backtest - Whether the session belongs to a backtest run (part of the entity key)
      */
-    constructor(strategyName: string, exchangeName: string, frameName: string);
+    constructor(strategyName: string, exchangeName: string, frameName: string, symbol: string, backtest: boolean);
     /**
      * Initializes the underlying PersistBase storage.
      *
@@ -16720,13 +17360,13 @@ declare class PersistSessionInstance implements IPersistSessionInstance {
      */
     waitForInit(initial: boolean): Promise<void>;
     /**
-     * Reads the persisted session data using `frameName` as the entity key.
+     * Reads the persisted session data using the per-symbol entity key.
      *
      * @returns Promise resolving to session data or null if not found
      */
     readSessionData(): Promise<SessionData | null>;
     /**
-     * Writes the session data using `frameName` as the entity key.
+     * Writes the session data using the per-symbol entity key.
      *
      * @param data - Session data to persist
      * @returns Promise that resolves when write is complete
@@ -16742,7 +17382,7 @@ declare class PersistSessionInstance implements IPersistSessionInstance {
  * Constructor type for IPersistSessionInstance.
  * Used by PersistSessionUtils.usePersistSessionAdapter() to register custom adapters.
  */
-type TPersistSessionInstanceCtor = new (strategyName: string, exchangeName: string, frameName: string) => IPersistSessionInstance;
+type TPersistSessionInstanceCtor = new (strategyName: string, exchangeName: string, frameName: string, symbol: string, backtest: boolean) => IPersistSessionInstance;
 /**
  * Utility class for managing session persistence.
  *
@@ -16763,9 +17403,14 @@ declare class PersistSessionUtils {
     private PersistSessionInstanceCtor;
     /**
      * Memoized factory creating one IPersistSessionInstance per
-     * (strategyName, exchangeName, frameName) triple.
+     * (strategyName, exchangeName, frameName, symbol, backtest) tuple.
      */
     private getSessionStorage;
+    /**
+     * Builds the memoization key for the given context.
+     * Kept in sync with the getSessionStorage key function.
+     */
+    private static GET_KEY_FN;
     /**
      * Registers a custom IPersistSessionInstance constructor.
      * Clears the memoization cache so subsequent calls use the new adapter.
@@ -16783,7 +17428,7 @@ declare class PersistSessionUtils {
      * @param initial - Whether this is the first initialization
      * @returns Promise that resolves when initialization is complete
      */
-    waitForInit: (strategyName: string, exchangeName: string, frameName: string, initial: boolean) => Promise<void>;
+    waitForInit: (strategyName: string, exchangeName: string, frameName: string, initial: boolean, symbol: string, backtest: boolean) => Promise<void>;
     /**
      * Reads persisted session data for the given context.
      * Lazily initializes the instance on first access.
@@ -16793,7 +17438,7 @@ declare class PersistSessionUtils {
      * @param frameName - Frame identifier
      * @returns Promise resolving to session data or null if none persisted
      */
-    readSessionData: (strategyName: string, exchangeName: string, frameName: string) => Promise<SessionData | null>;
+    readSessionData: (strategyName: string, exchangeName: string, frameName: string, symbol: string, backtest: boolean) => Promise<SessionData | null>;
     /**
      * Writes session data for the given context.
      * Lazily initializes the instance on first access.
@@ -16805,7 +17450,7 @@ declare class PersistSessionUtils {
      * @param when - Logical timestamp this value belongs to (duplicates `data.when` for API consistency)
      * @returns Promise that resolves when write is complete
      */
-    writeSessionData: (data: SessionData, strategyName: string, exchangeName: string, frameName: string, when: Date) => Promise<void>;
+    writeSessionData: (data: SessionData, strategyName: string, exchangeName: string, frameName: string, when: Date, symbol: string, backtest: boolean) => Promise<void>;
     /**
      * Switches to PersistSessionDummyInstance (all operations are no-ops).
      */
@@ -16827,7 +17472,7 @@ declare class PersistSessionUtils {
      * @param exchangeName - Exchange identifier
      * @param frameName - Frame identifier
      */
-    dispose: (strategyName: string, exchangeName: string, frameName: string) => void;
+    dispose: (strategyName: string, exchangeName: string, frameName: string, symbol: string, backtest: boolean) => void;
 }
 /**
  * Global singleton instance of PersistSessionUtils.
@@ -18979,6 +19624,62 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }, dto: ISignalDto) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "take_profit" on the next backtest tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     *
+     * @example
+     * ```typescript
+     * // Report TP fill confirmed on the exchange
+     * await Backtest.commitCreateTakeProfit("BTCUSDT", {
+     *   exchangeName: "binance",
+     *   strategyName: "my-strategy",
+     *   frameName: "1m"
+     * }, { id: "tp-fill-001" });
+     * ```
+     */
+    commitCreateTakeProfit: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "stop_loss" on the next backtest tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     *
+     * @example
+     * ```typescript
+     * // Report SL fill confirmed on the exchange
+     * await Backtest.commitCreateStopLoss("BTCUSDT", {
+     *   exchangeName: "binance",
+     *   strategyName: "my-strategy",
+     *   frameName: "1m"
+     * }, { id: "sl-fill-001" });
+     * ```
+     */
+    commitCreateStopLoss: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for the current backtest iteration.
      *
@@ -20489,6 +21190,40 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }, dto: ISignalDto) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "take_profit" on the next live tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    commitCreateTakeProfit: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "stop_loss" on the next live tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    commitCreateStopLoss: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for the current live iteration.
      *
@@ -24398,7 +25133,7 @@ declare class SyncMarkdownService {
     private readonly loggerService;
     private getStorage;
     /**
-     * Subscribes to `syncSubject` to start receiving `SignalSyncContract` events.
+     * Subscribes to `syncSubject` to start receiving `OrderSyncContract` events.
      * Protected against multiple subscriptions via `singleshot` — subsequent calls
      * return the same unsubscribe function without re-subscribing.
      *
@@ -24433,7 +25168,7 @@ declare class SyncMarkdownService {
      */
     unsubscribe: () => Promise<void>;
     /**
-     * Handles a single `SignalSyncContract` event emitted by `syncSubject`.
+     * Handles a single `OrderSyncContract` event emitted by `syncSubject`.
      *
      * Maps the contract fields to a `SyncEvent`, enriching it with a
      * `createdAt` ISO timestamp from `getContextTimestamp()` (backtest clock
@@ -24444,8 +25179,8 @@ declare class SyncMarkdownService {
      * Routes the constructed event to the appropriate `ReportStorage` bucket
      * via `getStorage(symbol, strategyName, exchangeName, frameName, backtest)`.
      *
-     * @param data - Discriminated union `SignalSyncContract`
-     *   (`SignalOpenContract | SignalCloseContract`)
+     * @param data - Discriminated union `OrderSyncContract`
+     *   (`OrderOpenContract | OrderCloseContract`)
      */
     private tick;
     /**
@@ -24726,8 +25461,8 @@ type TStorageUtilsCtor = new () => IStorageUtils;
  *
  * Features:
  * - Adapter pattern for swappable storage implementations
- * - Default adapter: StoragePersistBacktestUtils (persistent storage)
- * - Alternative adapters: StorageMemoryBacktestUtils, StorageDummyBacktestUtils
+ * - Default adapter: StorageMemoryBacktestUtils (in-memory storage)
+ * - Alternative adapters: StoragePersistBacktestUtils, StorageDummyBacktestUtils
  * - Convenience methods: usePersist(), useMemory(), useDummy()
  */
 declare class StorageBacktestAdapter implements IStorageUtils {
@@ -25274,7 +26009,7 @@ interface INotificationTarget {
      * Signal synchronization events for live trading (`signal_sync.open`, `signal_sync.close`).
      * Fired when a limit order is confirmed filled (`signal-open`) or when an open
      * position is confirmed exited (`signal-close`) by the exchange sync layer.
-     * Source: `syncSubject` (SignalSyncContract).
+     * Source: `syncSubject` (OrderSyncContract).
      */
     signal_sync: boolean;
     /**
@@ -25345,7 +26080,7 @@ interface INotificationUtils {
      * Handles signal sync event (signal-open, signal-close).
      * @param data - The signal sync contract data
      */
-    handleSync(data: SignalSyncContract): Promise<void>;
+    handleSync(data: OrderSyncContract): Promise<void>;
     /**
      * Handles risk rejection event.
      * @param data - The risk contract data
@@ -25437,7 +26172,7 @@ declare class NotificationBacktestAdapter implements INotificationUtils {
      * Proxies call to the underlying notification adapter.
      * @param data - The signal sync contract data
      */
-    handleSync: (data: SignalSyncContract) => any;
+    handleSync: (data: OrderSyncContract) => any;
     /**
      * Handles risk rejection event.
      * Proxies call to the underlying notification adapter.
@@ -25558,7 +26293,7 @@ declare class NotificationLiveAdapter implements INotificationUtils {
      * Proxies call to the underlying notification adapter.
      * @param data - The signal sync contract data
      */
-    handleSync: (data: SignalSyncContract) => any;
+    handleSync: (data: OrderSyncContract) => any;
     /**
      * Handles risk rejection event.
      * Proxies call to the underlying notification adapter.
@@ -26450,7 +27185,8 @@ declare class ExchangeUtils {
     /**
      * Fetches raw candles with flexible date/limit parameters.
      *
-     * Uses Date.now() instead of execution context when for look-ahead bias protection.
+     * Look-ahead bias protection: the reference "now" is execution context `when`
+     * when a context is active (backtest), otherwise the current wall-clock time.
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param interval - Candle interval (e.g., "1m", "1h")
@@ -28684,12 +29420,18 @@ declare class ActionBase implements IPublicAction {
 /**
  * Payload for the signal-open broker event.
  *
- * Emitted automatically via syncSubject when a new pending signal is activated.
- * Forwarded to the registered IBroker adapter via `onSignalOpenCommit`.
+ * Emitted automatically via syncSubject and forwarded to the registered IBroker adapter via
+ * `onOrderOpenCommit`. Discriminated by `type`:
+ * - "active" — a pending signal is being opened (immediate entry or activation fill of the
+ *   resting order); throw = the exchange did not fill the entry, the framework rolls back the
+ *   open and retries on the next tick;
+ * - "schedule" — the resting entry order is being PLACED (scheduled signal creation); throw =
+ *   the exchange did not accept the resting order, the scheduled signal is NOT registered and
+ *   the placement retries on the next tick.
  *
  * @example
  * ```typescript
- * const payload: BrokerSignalOpenPayload = {
+ * const payload: BrokerOrderOpenPayload = {
  *   symbol: "BTCUSDT",
  *   cost: 100,
  *   position: "long",
@@ -28701,7 +29443,9 @@ declare class ActionBase implements IPublicAction {
  * };
  * ```
  */
-type BrokerSignalOpenPayload = {
+type BrokerOrderOpenPayload = {
+    /** Which order is being opened: "active" — position entry, "schedule" — resting entry order placement */
+    type: "schedule" | "active";
     /** Trading pair symbol, e.g. "BTCUSDT" */
     symbol: string;
     /** Unique signal identifier (UUID v4) the order belongs to */
@@ -28735,11 +29479,11 @@ type BrokerSignalOpenPayload = {
  * Payload for the signal-close broker event.
  *
  * Emitted automatically via syncSubject when a pending signal is closed (SL/TP hit or manual close).
- * Forwarded to the registered IBroker adapter via `onSignalCloseCommit`.
+ * Forwarded to the registered IBroker adapter via `onOrderCloseCommit`.
  *
  * @example
  * ```typescript
- * const payload: BrokerSignalClosePayload = {
+ * const payload: BrokerOrderClosePayload = {
  *   symbol: "BTCUSDT",
  *   cost: 100,
  *   position: "long",
@@ -28754,7 +29498,7 @@ type BrokerSignalOpenPayload = {
  * };
  * ```
  */
-type BrokerSignalClosePayload = {
+type BrokerOrderClosePayload = {
     /** Trading pair symbol, e.g. "BTCUSDT" */
     symbol: string;
     /** Unique signal identifier (UUID v4) the order belongs to */
@@ -28791,16 +29535,25 @@ type BrokerSignalClosePayload = {
     backtest: boolean;
 };
 /**
- * Payload for the pending-order synchronization broker event.
+ * Payload for the order synchronization broker event.
  *
- * Emitted automatically via syncPendingSubject on every live tick while a pending signal is
- * monitored, BEFORE the framework evaluates TP/SL/time. Forwarded to the registered IBroker
- * adapter via `onOrderPing`.
+ * Emitted automatically via syncPendingSubject on every live tick while a signal is monitored,
+ * BEFORE the framework evaluates completion. Forwarded to the registered IBroker adapter,
+ * routed by `type` to the matching callback:
+ * - `type: "active"` — pending signal (open position), before TP/SL/time evaluation —
+ *   delivered to `onOrderActiveCheck`;
+ * - `type: "schedule"` — scheduled signal, before timeout/price-activation evaluation
+ *   (the order in question is the resting entry order) — delivered to `onOrderScheduleCheck`.
  *
  * The adapter should query the exchange by `signalId` and THROW ONLY when the order is
  * definitively NOT FOUND by that id (filled, cancelled, or liquidated externally). A throw
  * propagates to CREATE_SYNC_PENDING_FN, which makes the framework close the pending signal with
- * closeReason "closed". Returning normally keeps the position under normal TP/SL monitoring.
+ * closeReason "closed" (type "active") or cancel the scheduled signal with reason "user"
+ * (type "schedule"). Returning normally keeps the signal under normal monitoring.
+ *
+ * NOTE for type "schedule": if the resting entry order actually FILLED, confirm the fill via
+ * `commitActivateScheduled` instead of throwing — a throw here is a terminal cancel, not an
+ * activation.
  *
  * CRITICAL: transient/network errors (timeout, 5xx, rate limit, disconnect) must be SWALLOWED —
  * return normally instead of throwing. A thrown network error would wrongly close an open
@@ -28808,7 +29561,7 @@ type BrokerSignalClosePayload = {
  *
  * @example
  * ```typescript
- * const payload: BrokerSignalPendingPayload = {
+ * const payload: BrokerOrderCheckPayload = {
  *   symbol: "BTCUSDT",
  *   position: "long",
  *   currentPrice: 50500,
@@ -28820,7 +29573,9 @@ type BrokerSignalClosePayload = {
  * };
  * ```
  */
-type BrokerSignalPendingPayload = {
+type BrokerOrderCheckPayload = {
+    /** Monitored state: "active" — open position order, "schedule" — resting entry order */
+    type: "schedule" | "active";
     /** Trading pair symbol, e.g. "BTCUSDT" */
     symbol: string;
     /** Unique signal identifier (UUID v4) the order belongs to */
@@ -28854,6 +29609,316 @@ type BrokerSignalPendingPayload = {
     /** true when called during a backtest run — adapter should skip exchange calls */
     backtest: boolean;
 };
+/**
+ * Payload for the active-ping broker event.
+ *
+ * Emitted automatically via activePingSubject on every live tick while a pending (open) signal is
+ * monitored. Forwarded to the registered IBroker adapter via `onSignalActivePing`. Purely
+ * informational — unlike `onOrderActiveCheck` a throw here does NOT close the position.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerActivePingPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 50500,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerActivePingPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the monitored position */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of the ping */
+    currentPrice: number;
+    /** Effective entry price (may differ from priceOpen after DCA averaging) */
+    priceOpen: number;
+    /** Effective take-profit price at the moment of the ping */
+    priceTakeProfit: number;
+    /** Effective stop-loss price at the moment of the ping */
+    priceStopLoss: number;
+    /** Unrealized PnL of the open position at the moment of the ping */
+    pnl: IStrategyPnL;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the schedule-ping broker event.
+ *
+ * Emitted automatically via schedulePingSubject on every live tick while a scheduled signal is
+ * monitored (waiting for priceOpen activation). Forwarded to the registered IBroker adapter via
+ * `onSignalSchedulePing`. Purely informational.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerSchedulePingPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 49800,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerSchedulePingPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the scheduled signal */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of the ping */
+    currentPrice: number;
+    /** Pending entry price the scheduled signal is waiting for */
+    priceOpen: number;
+    /** Take-profit price configured for the scheduled signal */
+    priceTakeProfit: number;
+    /** Stop-loss price configured for the scheduled signal */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the idle-ping broker event.
+ *
+ * Emitted automatically via idlePingSubject on every live tick while the strategy has no pending or
+ * scheduled signal. Forwarded to the registered IBroker adapter via `onSignalIdlePing`. Purely
+ * informational — carries no signal because none is active.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerIdlePingPayload = {
+ *   symbol: "BTCUSDT",
+ *   currentPrice: 50500,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerIdlePingPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Market price at the moment of the ping */
+    currentPrice: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the scheduled-signal-open broker event.
+ *
+ * Emitted automatically via scheduleEventSubject (action "scheduled") when a new scheduled signal is
+ * created and starts waiting for priceOpen activation. Forwarded to the registered IBroker adapter
+ * via `onSignalScheduleOpen`. The scheduled -> active transition is NOT reported here — activation
+ * arrives through `onOrderOpenCommit`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerScheduleOpenPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 49800,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerScheduleOpenPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the scheduled signal */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment the scheduled signal was created */
+    currentPrice: number;
+    /** Pending entry price the scheduled signal waits for */
+    priceOpen: number;
+    /** Take-profit price configured for the scheduled signal */
+    priceTakeProfit: number;
+    /** Stop-loss price configured for the scheduled signal */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the scheduled-signal-cancelled broker event.
+ *
+ * Emitted automatically via scheduleEventSubject (action "cancelled") when a scheduled signal is
+ * removed before it ever activated. Forwarded to the registered IBroker adapter via
+ * `onSignalScheduleCancelled`. The `reason` distinguishes timeout / price reject / user cancel.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerScheduleCancelledPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 47500,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   reason: "price_reject",
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerScheduleCancelledPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the cancelled scheduled signal */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of cancellation */
+    currentPrice: number;
+    /** Pending entry price the scheduled signal had been waiting for */
+    priceOpen: number;
+    /** Take-profit price that had been configured for the scheduled signal */
+    priceTakeProfit: number;
+    /** Stop-loss price that had been configured for the scheduled signal */
+    priceStopLoss: number;
+    /** Why the scheduled signal was cancelled: "timeout" / "price_reject" / "user" */
+    reason?: StrategyCancelReason;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the pending-signal-open broker event.
+ *
+ * Emitted automatically via signalEventSubject (action "opened") when a pending position is opened
+ * (new signal / immediate entry / scheduled or user activation). Forwarded to the registered IBroker
+ * adapter via `onSignalPendingOpen`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerPendingOpenPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 50000,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerPendingOpenPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the opened position */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Effective entry price at the moment the position opened */
+    currentPrice: number;
+    /** Effective entry price (may differ from currentPrice after DCA averaging) */
+    priceOpen: number;
+    /** Take-profit price configured for the position */
+    priceTakeProfit: number;
+    /** Stop-loss price configured for the position */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the pending-signal-close broker event.
+ *
+ * Emitted automatically via signalEventSubject (action "closed") when a pending position is closed.
+ * Forwarded to the registered IBroker adapter via `onSignalPendingClose`. The `closeReason`
+ * distinguishes take_profit / stop_loss / time_expired / user-close / broker fill / order gone.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerPendingClosePayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 55000,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   closeReason: "take_profit",
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerPendingClosePayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the closed position */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of close */
+    currentPrice: number;
+    /** Effective entry price of the closed position */
+    priceOpen: number;
+    /** Effective take-profit price of the closed position */
+    priceTakeProfit: number;
+    /** Effective stop-loss price of the closed position */
+    priceStopLoss: number;
+    /** Why the position closed: "take_profit" / "stop_loss" / "time_expired" / "closed" */
+    closeReason?: StrategyCloseReason;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
 /**
  * Payload for a partial-profit close broker event.
  *
@@ -29131,7 +30196,7 @@ type BrokerAverageBuyPayload = {
  *   async waitForInit() {
  *     await this.exchange.connect();
  *   }
- *   async onSignalOpenCommit(payload) {
+ *   async onOrderOpenCommit(payload) {
  *     await this.exchange.placeOrder({ symbol: payload.symbol, side: payload.position });
  *   }
  *   // ... other methods
@@ -29143,21 +30208,264 @@ type BrokerAverageBuyPayload = {
 interface IBroker {
     /** Called once before first use. Connect to exchange, load credentials, etc. */
     waitForInit(): Promise<void>;
-    /** Called when a new signal is closed (take-profit, stop-loss, or manual close). */
-    onSignalCloseCommit(payload: BrokerSignalClosePayload): Promise<void>;
-    /** Called when a new signal is opened (position entry confirmed). */
-    onSignalOpenCommit(payload: BrokerSignalOpenPayload): Promise<void>;
     /**
-     * Called on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation.
+     * Called when a signal is being closed (take-profit, stop-loss, or manual close). Emitted via
+     * syncSubject BEFORE the framework mutates strategy state, so it is also the close **gate**.
+     *
+     * MANUAL WIRING — EXCEPTION-BASED: place the real exit order here (tag/look up by `payload.signalId`)
+     * and record final PnL. This is the confirmed-close commit; like `onOrderSync` (signal-close) it
+     * shares the gate semantics — a THROW means "the exchange did not close the position" and the
+     * framework SKIPS the close, leaving the position open and retrying on the next tick. Return
+     * normally to let the close proceed. Backtest short-circuits this (no live exchange), so the gate is
+     * live-only.
+     *
+     * This differs from `onSignalPendingClose`, which is the informational lifecycle hook that fires
+     * AFTER the close is committed (and cannot veto it).
+     */
+    onOrderCloseCommit(payload: BrokerOrderClosePayload): Promise<void>;
+    /**
+     * Called when an order is being opened. Emitted via syncSubject BEFORE the framework mutates
+     * strategy state, so it is also the open **gate**. Discriminated by `payload.type`:
+     * - "active" — position entry (immediate open or activation fill of the resting order);
+     * - "schedule" — PLACEMENT of the resting entry order at scheduled-signal creation.
+     *
+     * MANUAL WIRING — EXCEPTION-BASED: place the real order here (tag the exchange order with
+     * `payload.signalId` so later `onOrderActiveCheck` / `onOrderScheduleCheck` / `onSignalActivePing` can find it). Like `onOrderSync`
+     * (signal-open) it shares the gate semantics — a THROW means "the exchange did not accept/fill the
+     * order" and the framework ROLLS BACK: for type "active" the pending signal returns to idle (a
+     * scheduled activation is cancelled); for type "schedule" the scheduled signal is NOT registered
+     * and the risk reservation is released. Both retry on the next tick. Return normally to let the
+     * open proceed. Backtest short-circuits this, so the gate is live-only.
+     *
+     * This differs from `onSignalPendingOpen`, which is the informational lifecycle hook that fires
+     * AFTER the open is committed (and cannot veto it).
+     */
+    onOrderOpenCommit(payload: BrokerOrderOpenPayload): Promise<void>;
+    /**
+     * Called on every live tick while a pending signal (open position) is monitored,
+     * BEFORE TP/SL/time evaluation (`payload.type` is always "active").
+     *
      * Query the exchange by `payload.signalId` and THROW ONLY when the order is NOT FOUND by that id
-     * — the framework will then close the position with closeReason "closed". Return normally to keep
-     * monitoring.
+     * — the framework will then close the position with closeReason "closed". Return normally to
+     * keep monitoring.
      *
      * CRITICAL: swallow transient/network errors (timeout, 5xx, rate limit, disconnect) — return
      * normally instead of throwing, otherwise a connectivity blip would wrongly close an open
      * position. Throw exclusively on a confirmed "order not found by id" result.
+     *
+     * Manual wiring — EXCEPTION-BASED VARIANT
+     *
+     * This is the throw-driven **alternative** to the imperative commit-function wiring in
+     * `onSignalActivePing`:
+     * - **Exception-based (here):** THROW → framework closes the position with closeReason "closed".
+     *   One binary gate, no reason distinction. Good when "order gone" is the only condition you handle.
+     * - **Imperative (`onSignalActivePing` + `src/function/strategy.ts`):** call
+     *   `commitClosePending` / `commitCreateTakeProfit` / `commitCreateStopLoss` to close with the
+     *   correct reason and handle TP vs SL vs no-counterparty separately.
+     *
+     * Pick ONE per condition — do not both throw here AND `commitClosePending` in the active-ping for
+     * the same "order gone" event.
+     *
+     * @example
+     * ```typescript
+     * async onOrderActiveCheck(payload: BrokerOrderCheckPayload) {
+     *   let order: Order | null;
+     *   try {
+     *     order = await this.exchange.getOrderById(payload.signalId);
+     *   } catch (networkError) {
+     *     return; // transient — keep the position open, retry next tick
+     *   }
+     *   if (!order) {
+     *     throw new Error(`Order ${payload.signalId} not found`); // confirmed gone -> close "closed"
+     *   }
+     * }
+     * ```
+     */
+    onOrderActiveCheck(payload: BrokerOrderCheckPayload): Promise<void>;
+    /**
+     * Called on every live tick while a scheduled signal (resting entry order) is monitored,
+     * BEFORE timeout/price-activation evaluation (`payload.type` is always "schedule").
+     *
+     * Query the exchange by `payload.signalId` and THROW ONLY when the resting order is NOT FOUND
+     * by that id — the framework will then cancel the scheduled signal with reason "user". Return
+     * normally to keep monitoring. A FILLED resting order must be confirmed via
+     * `commitActivateScheduled`, not by throwing here (a throw is a terminal cancel, not an
+     * activation).
+     *
+     * CRITICAL: swallow transient/network errors (timeout, 5xx, rate limit, disconnect) — return
+     * normally instead of throwing, otherwise a connectivity blip would wrongly cancel the resting
+     * order. Throw exclusively on a confirmed "order not found by id" result.
+     *
+     * Manual wiring — EXCEPTION-BASED VARIANT: the throw-driven alternative to the imperative
+     * commit-function wiring in `onSignalSchedulePing` (`commitActivateScheduled` /
+     * `commitCancelScheduled`). Pick ONE per condition.
+     *
+     * @example
+     * ```typescript
+     * async onOrderScheduleCheck(payload: BrokerOrderCheckPayload) {
+     *   let order: Order | null;
+     *   try {
+     *     order = await this.exchange.getOrderById(payload.signalId);
+     *   } catch (networkError) {
+     *     return; // transient — keep the resting order monitored, retry next tick
+     *   }
+     *   if (!order) {
+     *     throw new Error(`Order ${payload.signalId} not found`); // confirmed gone -> cancel "user"
+     *   }
+     * }
+     * ```
+     */
+    onOrderScheduleCheck(payload: BrokerOrderCheckPayload): Promise<void>;
+    /**
+     * Called on every live tick while a pending (open) signal is monitored.
+     * Purely informational mirror of the active-ping lifecycle — a throw here does NOT close the
+     * position (unlike `onOrderActiveCheck`).
+     *
+     * Manual wiring — EVENT-BASED (driving an open position from real exchange state)
+     *
+     * Primary per-tick **event-based** hook for an open position (a throw does NOT close it — react to
+     * the event and decide imperatively). This is where you reconcile the framework's VWAP view with
+     * real fills: catch a **SL that gapped through** the level, or a **TP that filled before VWAP**
+     * reached it. Poll your real order and translate its state into strategy state via the
+     * commit-functions from `src/function/strategy.ts` (callable here because the ping is emitted inside
+     * the strategy tick; effects are deferred to the next tick):
+     * - `commitCreateTakeProfit(symbol, { id })` — real TP order filled (possibly before VWAP reached
+     *   the level) → force close, reason "take_profit".
+     * - `commitCreateStopLoss(symbol, { id })` — real SL order filled (e.g. price gapped through SL) →
+     *   force close, reason "stop_loss".
+     * - `commitClosePending(symbol, { id })` — no counterparty (no buyer/seller, liquidity gap) → close
+     *   now with reason "closed", instead of throwing.
+     *
+     * @example
+     * ```typescript
+     * import { commitCreateTakeProfit, commitCreateStopLoss, commitClosePending } from "backtest-kit";
+     *
+     * async onSignalActivePing(payload: BrokerActivePingPayload) {
+     *   const order = await this.exchange.getOrderById(payload.signalId);
+     *   if (order?.status === "filled" && order.kind === "take_profit") {
+     *     await commitCreateTakeProfit(payload.symbol, { id: order.id });
+     *   } else if (order?.status === "filled" && order.kind === "stop_loss") {
+     *     await commitCreateStopLoss(payload.symbol, { id: order.id });
+     *   } else if (order?.status === "no_counterparty") {
+     *     await commitClosePending(payload.symbol, { id: order.id });
+     *   }
+     * }
+     * ```
+     */
+    onSignalActivePing(payload: BrokerActivePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while a scheduled signal is monitored (waiting for priceOpen
+     * activation). Purely informational.
+     *
+     * Manual wiring — EVENT-BASED (driving the scheduled phase from real exchange state)
+     *
+     * Per-tick **event-based** hook (a throw does NOT veto anything — react and decide imperatively).
+     * Poll your real resting/limit order and translate it via the commit-functions from
+     * `src/function/strategy.ts` (deferred to the next tick):
+     * - `commitActivateScheduled(symbol, { id })` — resting order filled/resolved → activate now,
+     *   without waiting for VWAP to reach priceOpen (surfaces as `onOrderOpenCommit` next tick).
+     * - `commitCancelScheduled(symbol, { id })` — resting order cancelled/rejected externally → drop it.
+     *
+     * @example
+     * ```typescript
+     * import { commitActivateScheduled, commitCancelScheduled } from "backtest-kit";
+     *
+     * async onSignalSchedulePing(payload: BrokerSchedulePingPayload) {
+     *   const order = await this.exchange.getOrderById(payload.signalId);
+     *   if (order?.status === "filled" || order?.status === "resolved") {
+     *     await commitActivateScheduled(payload.symbol, { id: order.id });
+     *   } else if (order?.status === "cancelled" || order?.status === "rejected") {
+     *     await commitCancelScheduled(payload.symbol, { id: order.id });
+     *   }
+     * }
+     * ```
+     */
+    onSignalSchedulePing(payload: BrokerSchedulePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while the strategy is idle (no pending or scheduled signal).
+     * Purely informational.
+     *
+     * MANUAL WIRING — EVENT-BASED: no signal is active, so there is nothing to commit; use it for idle
+     * heartbeats / housekeeping. A throw does not affect strategy state.
+     */
+    onSignalIdlePing(payload: BrokerIdlePingPayload): Promise<void>;
+    /**
+     * Called when a new scheduled signal is created and starts waiting for priceOpen activation.
+     * The scheduled -> active transition is reported via `onOrderOpenCommit`, not here.
+     *
+     * Manual wiring — EVENT-BASED (placing the resting order)
+     *
+     * Fires ONCE at creation — place the real resting/limit order (tag it with `payload.signalId` so
+     * `onSignalSchedulePing` can poll it later). If it resolves immediately, promote it with
+     * `commitActivateScheduled(symbol, { id })`; if rejected, drop it with
+     * `commitCancelScheduled(symbol, { id })`. Use `onSignalSchedulePing` for ongoing polling.
+     *
+     * @example
+     * ```typescript
+     * import { commitActivateScheduled, commitCancelScheduled } from "backtest-kit";
+     *
+     * async onSignalScheduleOpen(payload: BrokerScheduleOpenPayload) {
+     *   const order = await this.exchange.placeLimitOrder({
+     *     id: payload.signalId,
+     *     symbol: payload.symbol,
+     *     side: payload.position,
+     *     price: payload.priceOpen,
+     *   });
+     *   if (order.status === "filled") await commitActivateScheduled(payload.symbol, { id: order.id });
+     *   else if (order.status === "rejected") await commitCancelScheduled(payload.symbol, { id: order.id });
+     * }
+     * ```
+     */
+    onSignalScheduleOpen(payload: BrokerScheduleOpenPayload): Promise<void>;
+    /**
+     * Called when a scheduled signal is cancelled before it ever activated
+     * (reason: timeout / price_reject / user).
+     *
+     * Manual wiring — EVENT-BASED (tearing down the resting order)
+     *
+     * Outbound side — the framework has already dropped the scheduled signal, so there is nothing to
+     * `commitCancelScheduled` here; instead cancel the real resting order you placed in
+     * `onSignalScheduleOpen` (look it up by `payload.signalId`). `payload.reason` tells you why.
+     *
+     * @example
+     * ```typescript
+     * async onSignalScheduleCancelled(payload: BrokerScheduleCancelledPayload) {
+     *   await this.exchange.cancelOrderById(payload.signalId);
+     * }
+     * ```
+     */
+    onSignalScheduleCancelled(payload: BrokerScheduleCancelledPayload): Promise<void>;
+    /**
+     * Called when a pending position is opened (new signal / immediate / scheduled or user
+     * activation). Purely informational lifecycle hook for the active phase of a signal.
+     *
+     * Manual wiring — EVENT-BASED (placing entry + protective orders)
+     *
+     * Fires ONCE at open — place the real entry confirmation and protective TP/SL orders (tag them with
+     * `payload.signalId`). Drive the rest per-tick from `onSignalActivePing`. This hook does not gate
+     * the position; for a true entry gate use `onOrderSync` (signal-open).
+     */
+    onSignalPendingOpen(payload: BrokerPendingOpenPayload): Promise<void>;
+    /**
+     * Called when a pending position is closed
+     * (reason: take_profit / stop_loss / time_expired / closed).
+     *
+     * Manual wiring — EVENT-BASED (tearing down the position)
+     *
+     * Outbound side — the framework has already removed the pending signal, so there is nothing to
+     * `commitClosePending` here; instead flatten the real position and cancel leftover TP/SL orders by
+     * `payload.signalId`, and record final PnL. `payload.closeReason` says which path closed it. If you
+     * need to FORCE the close yourself (e.g. no counterparty), do it earlier in `onSignalActivePing`.
+     *
+     * @example
+     * ```typescript
+     * async onSignalPendingClose(payload: BrokerPendingClosePayload) {
+     *   await this.exchange.flatten(payload.symbol);
+     *   await this.exchange.cancelProtectiveOrders(payload.signalId);
+     * }
+     * ```
      */
-    onOrderPing(payload: BrokerSignalPendingPayload): Promise<void>;
+    onSignalPendingClose(payload: BrokerPendingClosePayload): Promise<void>;
     /** Called when a partial profit close is committed. */
     onPartialProfitCommit(payload: BrokerPartialProfitPayload): Promise<void>;
     /** Called when a partial loss close is committed. */
@@ -29180,7 +30488,7 @@ interface IBroker {
  * @example
  * ```typescript
  * class MyBroker implements Partial<IBroker> {
- *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) { ... }
+ *   async onOrderOpenCommit(payload: BrokerOrderOpenPayload) { ... }
  * }
  *
  * Broker.useBrokerAdapter(MyBroker); // MyBroker satisfies TBrokerCtor
@@ -29240,7 +30548,7 @@ declare class BrokerAdapter {
      *
      * @example
      * ```typescript
-     * await Broker.commitSignalOpen({
+     * await Broker.commitOrderOpen({
      *   symbol: "BTCUSDT",
      *   cost: 100,
      *   position: "long",
@@ -29252,7 +30560,7 @@ declare class BrokerAdapter {
      * });
      * ```
      */
-    commitSignalOpen: (payload: BrokerSignalOpenPayload) => Promise<void>;
+    commitOrderOpen: (payload: BrokerOrderOpenPayload) => Promise<void>;
     /**
      * Forwards a signal-close event to the registered broker adapter.
      *
@@ -29263,7 +30571,7 @@ declare class BrokerAdapter {
      *
      * @example
      * ```typescript
-     * await Broker.commitSignalClose({
+     * await Broker.commitOrderClose({
      *   symbol: "BTCUSDT",
      *   cost: 100,
      *   position: "long",
@@ -29278,18 +30586,95 @@ declare class BrokerAdapter {
      * });
      * ```
      */
-    commitSignalClose: (payload: BrokerSignalClosePayload) => Promise<void>;
+    commitOrderClose: (payload: BrokerOrderClosePayload) => Promise<void>;
     /**
-     * Forwards a pending-order ping to the registered broker adapter.
+     * Forwards an order ping to the registered broker adapter.
      *
      * Called automatically via syncPendingSubject when `enable()` is active, on every live tick
-     * while a pending signal is monitored. Skipped silently in backtest mode or when no adapter is
-     * registered. Exceptions are NOT swallowed: a throw from the adapter propagates up to
-     * syncPendingSubject.next() → CREATE_SYNC_PENDING_FN, which closes the position with "closed".
+     * while a pending signal (payload.type "active") or a scheduled signal (payload.type
+     * "schedule") is monitored — routed to `onOrderActiveCheck` / `onOrderScheduleCheck`
+     * respectively. Skipped silently in backtest mode or when no adapter is registered.
+     * Exceptions are NOT swallowed: a throw from the adapter propagates up to
+     * syncPendingSubject.next() → CREATE_SYNC_PENDING_FN, which closes the position with "closed"
+     * (type "active") or cancels the scheduled signal with reason "user" (type "schedule").
+     *
+     * @param payload - Order ping details: type, symbol, position, prices, pnl, context, backtest flag
+     */
+    commitOrderCheck: (payload: BrokerOrderCheckPayload) => Promise<void>;
+    /**
+     * Forwards an active-ping to the registered broker adapter.
+     *
+     * Called automatically via activePingSubject when `enable()` is active, on every live tick while a
+     * pending signal is monitored. Skipped silently in backtest mode or when no adapter is registered.
+     * Purely informational — a throw does NOT close the position.
+     *
+     * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    commitActivePing: (payload: BrokerActivePingPayload) => Promise<void>;
+    /**
+     * Forwards a schedule-ping to the registered broker adapter.
+     *
+     * Called automatically via schedulePingSubject when `enable()` is active, on every live tick while
+     * a scheduled signal is monitored. Skipped silently in backtest mode or when no adapter is
+     * registered. Purely informational.
+     *
+     * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest
+     */
+    commitSchedulePing: (payload: BrokerSchedulePingPayload) => Promise<void>;
+    /**
+     * Forwards an idle-ping to the registered broker adapter.
+     *
+     * Called automatically via idlePingSubject when `enable()` is active, on every live tick while the
+     * strategy has no pending or scheduled signal. Skipped silently in backtest mode or when no adapter
+     * is registered. Purely informational.
+     *
+     * @param payload - Idle ping details: symbol, currentPrice, context, backtest
+     */
+    commitIdlePing: (payload: BrokerIdlePingPayload) => Promise<void>;
+    /**
+     * Forwards a scheduled-signal-open to the registered broker adapter.
+     *
+     * Called automatically via scheduleEventSubject (action "scheduled") when a scheduled signal is
+     * created. Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest
+     */
+    commitScheduleOpen: (payload: BrokerScheduleOpenPayload) => Promise<void>;
+    /**
+     * Forwards a scheduled-signal-cancelled to the registered broker adapter.
      *
-     * @param payload - Pending ping details: symbol, position, prices, pnl, context, backtest flag
+     * Called automatically via scheduleEventSubject (action "cancelled") when a scheduled signal is
+     * removed before activation. Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * IMPORTANT (adapter responsibility): the cancel may race the real fill. The framework decides
+     * to drop the scheduled signal from ITS view (risk reject at activation, sync reject, stop,
+     * timeout), but the resting limit order on the exchange may have ALREADY filled by the time this
+     * arrives. The adapter MUST check the actual order status before cancelling: if the order is
+     * filled, cancelling is a no-op on the exchange and the adapter owns the resulting position
+     * (close it or reconcile via onOrderActiveCheck / onSignalActivePing). The framework cannot model
+     * this case — from its side the signal is terminally cancelled.
+     *
+     * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest
+     */
+    commitScheduleCancelled: (payload: BrokerScheduleCancelledPayload) => Promise<void>;
+    /**
+     * Forwards a pending-signal-open to the registered broker adapter.
+     *
+     * Called automatically via signalEventSubject (action "opened") when a pending position is opened.
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest
+     */
+    commitPendingOpen: (payload: BrokerPendingOpenPayload) => Promise<void>;
+    /**
+     * Forwards a pending-signal-close to the registered broker adapter.
+     *
+     * Called automatically via signalEventSubject (action "closed") when a pending position is closed.
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest
      */
-    commitSignalPending: (payload: BrokerSignalPendingPayload) => Promise<void>;
+    commitPendingClose: (payload: BrokerPendingClosePayload) => Promise<void>;
     /**
      * Intercepts a partial-profit close before DI-core mutation.
      *
@@ -29528,8 +30913,8 @@ declare class BrokerAdapter {
  * 4. No explicit dispose — clean up in `waitForInit` teardown or externally
  *
  * Event flow (called only in live mode, skipped in backtest):
- * - `onSignalOpenCommit` — new position opened
- * - `onSignalCloseCommit` — position closed (SL/TP hit or manual close)
+ * - `onOrderOpenCommit` — new position opened
+ * - `onOrderCloseCommit` — position closed (SL/TP hit or manual close)
  * - `onPartialProfitCommit` — partial close at profit executed
  * - `onPartialLossCommit` — partial close at loss executed
  * - `onTrailingStopCommit` — trailing stop-loss updated
@@ -29551,8 +30936,8 @@ declare class BrokerAdapter {
  *     await this.client.connect();
  *   }
  *
- *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
- *     super.onSignalOpenCommit(payload); // Call parent for logging
+ *   async onOrderOpenCommit(payload: BrokerOrderOpenPayload) {
+ *     super.onOrderOpenCommit(payload); // Call parent for logging
  *     await this.client!.placeOrder({
  *       symbol: payload.symbol,
  *       side: payload.position === "long" ? "BUY" : "SELL",
@@ -29560,8 +30945,8 @@ declare class BrokerAdapter {
  *     });
  *   }
  *
- *   async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
- *     super.onSignalCloseCommit(payload); // Call parent for logging
+ *   async onOrderCloseCommit(payload: BrokerOrderClosePayload) {
+ *     super.onOrderCloseCommit(payload); // Call parent for logging
  *     await this.client!.closePosition(payload.symbol);
  *   }
  * }
@@ -29575,11 +30960,11 @@ declare class BrokerAdapter {
  * ```typescript
  * // Minimal implementation — only handle opens and closes
  * class NotifyBroker extends BrokerBase {
- *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+ *   async onOrderOpenCommit(payload: BrokerOrderOpenPayload) {
  *     await sendTelegram(`Opened ${payload.position} on ${payload.symbol}`);
  *   }
  *
- *   async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+ *   async onOrderCloseCommit(payload: BrokerOrderClosePayload) {
  *     const pnl = payload.pnl.profit - payload.pnl.loss;
  *     await sendTelegram(`Closed ${payload.symbol}: PnL $${pnl.toFixed(2)}`);
  *   }
@@ -29606,30 +30991,39 @@ declare class BrokerBase implements IBroker {
      */
     waitForInit(): Promise<void>;
     /**
-     * Called when a new position is opened (signal activated).
+     * Called when a position is being opened (signal activated).
      *
      * Triggered automatically via syncSubject when a scheduled signal's priceOpen is hit.
      * Use to place the actual entry order on the exchange.
      *
      * Default implementation: Logs signal-open event.
      *
+     * Manual wiring — EXCEPTION-BASED GATE: emitted BEFORE the framework mutates state, so a THROW here
+     * (e.g. limit order rejected) rolls back the open — the pending signal returns to idle and retries
+     * next tick; return normally to let it open. Live-only (backtest short-circuits). See
+     * {@link IBroker.onOrderOpenCommit} for the full semantics.
+     *
      * @param payload - Signal open details: symbol, cost, position, priceOpen, priceTakeProfit, priceStopLoss, context, backtest
      *
      * @example
      * ```typescript
-     * async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
-     *   super.onSignalOpenCommit(payload); // Keep parent logging
-     *   await this.exchange.placeMarketOrder({
+     * async onOrderOpenCommit(payload: BrokerOrderOpenPayload) {
+     *   super.onOrderOpenCommit(payload); // Keep parent logging
+     *   const order = await this.exchange.placeMarketOrder({
      *     symbol: payload.symbol,
      *     side: payload.position === "long" ? "BUY" : "SELL",
      *     quantity: payload.cost / payload.priceOpen,
      *   });
+     *   if (!order.filled) {
+     *     throw new Error(`Entry not filled for ${payload.symbol}`); // -> roll back the open, retry next tick
+     *   }
      * }
      * ```
      */
-    onSignalOpenCommit(payload: BrokerSignalOpenPayload): Promise<void>;
+    onOrderOpenCommit(payload: BrokerOrderOpenPayload): Promise<void>;
     /**
-     * Called on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation.
+     * Called on every live tick while a pending signal (open position) is monitored, BEFORE
+     * TP/SL/time evaluation.
      *
      * Override to query the exchange for the order by `payload.signalId` and THROW ONLY when it is
      * definitively NOT FOUND by that id (filled, cancelled, or liquidated externally) — the framework
@@ -29640,47 +31034,143 @@ declare class BrokerBase implements IBroker {
      * normally instead of throwing. A thrown network error would wrongly close an open position; only
      * a confirmed "order not found by id" response is a valid reason to throw.
      *
+     * Manual wiring — EXCEPTION-BASED VARIANT: the throw-driven alternative to the imperative
+     * commit-function wiring in `onSignalActivePing`. See {@link IBroker.onOrderActiveCheck} for the
+     * full comparison and example.
+     *
      * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    onOrderActiveCheck(payload: BrokerOrderCheckPayload): Promise<void>;
+    /**
+     * Called on every live tick while a scheduled signal (resting entry order) is monitored, BEFORE
+     * timeout/price-activation evaluation.
      *
-     * @example
-     * ```typescript
-     * async onOrderPing(payload: BrokerSignalPendingPayload) {
-     *   super.onOrderPing(payload); // Keep parent logging
-     *   let order: Order | null;
-     *   try {
-     *     order = await this.exchange.getOrderById(payload.signalId);
-     *   } catch (networkError) {
-     *     // Transient/network error — swallow and keep the position open, retry next tick
-     *     return;
-     *   }
-     *   if (!order) {
-     *     // Confirmed not found by id — close the position
-     *     throw new Error(`Order ${payload.signalId} not found on the exchange`);
-     *   }
-     * }
-     * ```
+     * Override to query the exchange for the resting order by `payload.signalId` and THROW ONLY when
+     * it is definitively NOT FOUND by that id — the framework then cancels the scheduled signal with
+     * reason "user". The default implementation logs and returns normally. A FILLED resting order
+     * must be confirmed via `commitActivateScheduled`, not by throwing here.
+     *
+     * CRITICAL: swallow transient/network errors (timeout, 5xx, rate limit, disconnect) — return
+     * normally instead of throwing; only a confirmed "order not found by id" response is a valid
+     * reason to throw.
+     *
+     * Manual wiring — EXCEPTION-BASED VARIANT: the throw-driven alternative to the imperative
+     * commit-function wiring in `onSignalSchedulePing`. See {@link IBroker.onOrderScheduleCheck} for
+     * the full comparison and example.
+     *
+     * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    onOrderScheduleCheck(payload: BrokerOrderCheckPayload): Promise<void>;
+    /**
+     * Called on every live tick while a pending (open) signal is monitored.
+     *
+     * Purely informational mirror of the active-ping lifecycle — unlike `onOrderActiveCheck`, a throw here
+     * does NOT close the position. Override to mirror live monitoring state into your own systems.
+     * The default implementation logs.
+     *
+     * Manual wiring — EVENT-BASED: this is the primary per-tick hook to drive an open position from real exchange
+     * state (`commitCreateTakeProfit` / `commitCreateStopLoss` / `commitClosePending`). See the
+     * {@link IBroker.onSignalActivePing} contract docs for the full guidance and example.
+     *
+     * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    onSignalActivePing(payload: BrokerActivePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while a scheduled signal is monitored (waiting for priceOpen).
+     *
+     * Purely informational. Override to mirror scheduled-monitoring state. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: per-tick hook to drive a scheduled (resting) order from real exchange state
+     * (`commitActivateScheduled` / `commitCancelScheduled`). See {@link IBroker.onSignalSchedulePing}
+     * for full guidance and example.
+     *
+     * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest
+     */
+    onSignalSchedulePing(payload: BrokerSchedulePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while the strategy is idle (no pending or scheduled signal).
+     *
+     * Purely informational. Override to track idle heartbeats. The default logs.
+     *
+     * @param payload - Idle ping details: symbol, currentPrice, context, backtest
+     */
+    onSignalIdlePing(payload: BrokerIdlePingPayload): Promise<void>;
+    /**
+     * Called when a new scheduled signal is created and starts waiting for priceOpen activation.
+     *
+     * The scheduled -> active transition is reported via `onOrderOpenCommit`, not here. Override to
+     * place a resting/limit order on the exchange. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: fires ONCE at creation — place the real resting order (tag it with
+     * `payload.signalId`) and optionally `commitActivateScheduled` / `commitCancelScheduled`. See
+     * {@link IBroker.onSignalScheduleOpen} for full guidance and example.
+     *
+     * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest
+     */
+    onSignalScheduleOpen(payload: BrokerScheduleOpenPayload): Promise<void>;
+    /**
+     * Called when a scheduled signal is cancelled before activation (timeout / price_reject / user).
+     *
+     * Override to cancel the resting/limit order on the exchange. The default logs.
+     *
+     * Manual wiring — EVENT-BASED (outbound): the strategy already dropped the scheduled signal — cancel the matching
+     * exchange order by `payload.signalId`. See {@link IBroker.onSignalScheduleCancelled}.
+     *
+     * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest
+     */
+    onSignalScheduleCancelled(payload: BrokerScheduleCancelledPayload): Promise<void>;
+    /**
+     * Called when a pending position is opened (new signal / immediate / scheduled or user activation).
+     *
+     * Informational lifecycle hook. Override to mirror the open into your own systems. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: fires ONCE at open — place entry + protective TP/SL orders (tag with
+     * `payload.signalId`), then drive per-tick from `onSignalActivePing`. See
+     * {@link IBroker.onSignalPendingOpen}.
+     *
+     * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest
+     */
+    onSignalPendingOpen(payload: BrokerPendingOpenPayload): Promise<void>;
+    /**
+     * Called when a pending position is closed (take_profit / stop_loss / time_expired / closed).
+     *
+     * Informational lifecycle hook. Override to mirror the close into your own systems. The default logs.
+     *
+     * Manual wiring — EVENT-BASED (outbound): the strategy already removed the pending signal — flatten the real
+     * position and cancel leftover TP/SL orders by `payload.signalId`. See
+     * {@link IBroker.onSignalPendingClose}.
+     *
+     * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest
      */
-    onOrderPing(payload: BrokerSignalPendingPayload): Promise<void>;
+    onSignalPendingClose(payload: BrokerPendingClosePayload): Promise<void>;
     /**
-     * Called when a position is fully closed (SL/TP hit or manual close).
+     * Called when a position is being closed (SL/TP hit or manual close).
      *
      * Triggered automatically via syncSubject when a pending signal is closed.
      * Use to place the exit order and record final PnL.
      *
      * Default implementation: Logs signal-close event.
      *
+     * Manual wiring — EXCEPTION-BASED GATE: emitted BEFORE the framework mutates state, so a THROW here
+     * (e.g. exit order failed) SKIPS the close — the position stays open and the close retries next
+     * tick; return normally to let it close. Live-only (backtest short-circuits). See
+     * {@link IBroker.onOrderCloseCommit} for the full semantics.
+     *
      * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, totalEntries, totalPartials, context, backtest
      *
      * @example
      * ```typescript
-     * async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
-     *   super.onSignalCloseCommit(payload); // Keep parent logging
-     *   await this.exchange.closePosition(payload.symbol);
+     * async onOrderCloseCommit(payload: BrokerOrderClosePayload) {
+     *   super.onOrderCloseCommit(payload); // Keep parent logging
+     *   const ok = await this.exchange.closePosition(payload.symbol);
+     *   if (!ok) {
+     *     throw new Error(`Exit not filled for ${payload.symbol}`); // -> keep position open, retry next tick
+     *   }
      *   await this.db.recordTrade({ symbol: payload.symbol, pnl: payload.pnl });
      * }
      * ```
      */
-    onSignalCloseCommit(payload: BrokerSignalClosePayload): Promise<void>;
+    onOrderCloseCommit(payload: BrokerOrderClosePayload): Promise<void>;
     /**
      * Called when a partial close at profit is executed.
      *
@@ -29873,7 +31363,7 @@ interface WalkerStopContract {
  * This ensures that the framework's internal state remains consistent with the exchange's state.
  * Consumers should implement retry logic in their listeners to handle transient synchronization failures.
  */
-declare const syncSubject: Subject<SignalSyncContract>;
+declare const syncSubject: Subject<OrderSyncContract>;
 /**
  * Pending-order synchronization emitter.
  * Emitted on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation.
@@ -29882,7 +31372,7 @@ declare const syncSubject: Subject<SignalSyncContract>;
  * If a listener returns false OR throws, the order is treated as no longer open on the exchange
  * and the framework closes the pending signal with closeReason "closed". Never emitted in backtest.
  */
-declare const syncPendingSubject: Subject<SignalPingContract>;
+declare const syncPendingSubject: Subject<OrderCheckContract>;
 /**
  * Global signal emitter for all trading events (live + backtest).
  * Emits all signal events regardless of execution mode.
@@ -29993,6 +31483,22 @@ declare const riskSubject: Subject<RiskContract>;
  * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
  */
 declare const schedulePingSubject: Subject<SchedulePingContract>;
+/**
+ * Scheduled signal lifecycle emitter (creation and cancellation).
+ * Emits when a scheduled signal is created (action "scheduled") or cancelled before
+ * activation (action "cancelled": timeout / price_reject / user) during tick()/backtest().
+ *
+ * The scheduled -> active transition (activation) is intentionally NOT emitted here — that
+ * produces an "opened" signal on the regular signal emitters instead.
+ */
+declare const scheduleEventSubject: Subject<ScheduleEventContract>;
+/**
+ * Pending signal lifecycle emitter (open and close).
+ * Emits when a pending position is opened (action "opened": new signal / immediate / scheduled
+ * or user activation) or closed (action "closed" with closeReason take_profit / stop_loss /
+ * time_expired / closed) during tick()/backtest().
+ */
+declare const signalEventSubject: Subject<SignalEventContract>;
 /**
  * Active ping emitter for active pending signal monitoring events.
  * Emits every minute when an active pending signal is being monitored.
@@ -30081,10 +31587,12 @@ declare const emitters_performanceEmitter: typeof performanceEmitter;
 declare const emitters_progressBacktestEmitter: typeof progressBacktestEmitter;
 declare const emitters_progressWalkerEmitter: typeof progressWalkerEmitter;
 declare const emitters_riskSubject: typeof riskSubject;
+declare const emitters_scheduleEventSubject: typeof scheduleEventSubject;
 declare const emitters_schedulePingSubject: typeof schedulePingSubject;
 declare const emitters_shutdownEmitter: typeof shutdownEmitter;
 declare const emitters_signalBacktestEmitter: typeof signalBacktestEmitter;
 declare const emitters_signalEmitter: typeof signalEmitter;
+declare const emitters_signalEventSubject: typeof signalEventSubject;
 declare const emitters_signalLiveEmitter: typeof signalLiveEmitter;
 declare const emitters_signalNotifySubject: typeof signalNotifySubject;
 declare const emitters_strategyCommitSubject: typeof strategyCommitSubject;
@@ -30095,7 +31603,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_activePingSubject as activePingSubject, emitters_afterEndSubject as afterEndSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_beforeStartSubject as beforeStartSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_entrySubject as entrySubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_idlePingSubject as idlePingSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_signalNotifySubject as signalNotifySubject, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncPendingSubject as syncPendingSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, emitters_afterEndSubject as afterEndSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_beforeStartSubject as beforeStartSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_entrySubject as entrySubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_idlePingSubject as idlePingSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, 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_scheduleEventSubject as scheduleEventSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalEventSubject as signalEventSubject, emitters_signalLiveEmitter as signalLiveEmitter, emitters_signalNotifySubject as signalNotifySubject, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncPendingSubject as syncPendingSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -30139,10 +31647,13 @@ declare const waitForCandle: (interval: CandleInterval) => Promise<number>;
  * @param {string | number} price - The price to round, can be a string or number
  * @param {number} tickSize - The tick size that determines the precision (e.g., 0.01 for 2 decimal places)
  * @returns {string} The price rounded to the precision specified by the tick size
+ * @throws {Error} If tickSize is not a positive finite number
  *
  * @example
  * roundTicks(123.456789, 0.01) // returns "123.46"
  * roundTicks("100.12345", 0.001) // returns "100.123"
+ * roundTicks(123.456789, 1) // returns "123"
+ * roundTicks(123.456789, 1e-9) // returns "123.456789000"
  */
 declare const roundTicks: (price: string | number, tickSize: number) => string;
 
@@ -30300,69 +31811,113 @@ declare const set: (object: any, path: any, value: any) => boolean;
 
 /**
  * Calculate the percentage difference between two numbers.
+ *
+ * The result is how many percent the larger value exceeds the smaller one:
+ * percentDiff(100, 150) === 50, percentDiff(150, 100) === 50.
+ *
+ * Edge cases are reported honestly instead of a sentinel value:
+ * - Both values equal (including 0, 0) — returns 0.
+ * - One value is 0 and the other is not — returns Infinity
+ *   (the difference is unbounded; no finite percent can express it).
+ *
  * @param {number} a - The first number.
  * @param {number} b - The second number.
  * @returns {number} The percentage difference between the two numbers.
  */
-declare const percentDiff: (a?: number, b?: number) => number;
+declare const percentDiff: (a: number, b: number) => number;
 
 /**
  * Calculate the percentage change from yesterday's value to today's value.
- * @param {number} yesterdayValue - The value from yesterday.
+ *
+ * Formula: ((todayValue - yesterdayValue) / yesterdayValue) * 100
+ *
+ * Positive result — value grew, negative — value dropped.
+ *
+ * @param {number} yesterdayValue - The value from yesterday (base of comparison).
  * @param {number} todayValue - The value from today.
- * @returns {number} The percentage change from yesterday to today.
+ * @returns {number} The percentage change from yesterday to today (e.g. 5 for +5%).
+ *
+ * @example
+ * percentValue(100, 105); // 5
+ * percentValue(100, 95);  // -5
  */
 declare const percentValue: (yesterdayValue: number, todayValue: number) => number;
 
 /**
- * Convert an absolute dollar amount to a percentage of the invested position cost.
+ * Convert an absolute dollar amount to a percentage of a cost basis.
  * Use the result as the `percent` argument to `commitPartialProfit` / `commitPartialLoss`.
  *
+ * IMPORTANT: `percentToClose` in partial closes is applied to the REMAINING
+ * cost basis (what is still held after prior partials), not to the total
+ * invested amount. To close an exact dollar amount, pass the remaining cost
+ * basis from `getTotalCostClosed` as `costBasis` — not `getPositionInvestedCost`.
+ *
  * @param dollarAmount - Dollar value to close (e.g. 150)
- * @param investedCost - Total invested cost from `getPositionInvestedCost` (e.g. 300)
- * @returns Percentage of the position to close (0–100)
+ * @param costBasis - Remaining cost basis from `getTotalCostClosed` (e.g. 300)
+ * @returns Percentage of the remaining position to close (0–100)
  *
  * @example
- * const percent = investedCostToPercent(150, 300); // 50
+ * const remaining = await getTotalCostClosed("BTCUSDT"); // e.g. 300
+ * const percent = investedCostToPercent(150, remaining); // 50
  * await commitPartialProfit("BTCUSDT", percent);
  */
-declare const investedCostToPercent: (dollarAmount: number, investedCost: number) => number;
+declare const investedCostToPercent: (dollarAmount: number, costBasis: number) => number;
 
 /**
  * Convert an absolute stop-loss price to a percentShift for `commitTrailingStop`.
  *
  * percentShift = newSlDistancePercent - originalSlDistancePercent
- * where distance = Math.abs((effectivePriceOpen - slPrice) / effectivePriceOpen * 100)
+ *
+ * The new distance is SIGNED by position direction (mirrors how ClientStrategy
+ * applies the shift): a stop-loss moved past the entry into the profit zone
+ * produces a negative distance, so any target price is expressible —
+ * `slPercentShiftToPrice(slPriceToPercentShift(x, ...), ...) === x` holds for
+ * targets on both sides of the entry.
+ *
+ * LONG:  newSlDistancePercent = (effectivePriceOpen - newStopLossPrice) / effectivePriceOpen * 100
+ * SHORT: newSlDistancePercent = (newStopLossPrice - effectivePriceOpen) / effectivePriceOpen * 100
  *
  * @param newStopLossPrice - Desired absolute stop-loss price
  * @param originalStopLossPrice - Original stop-loss price from the pending signal
  * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
+ * @param position - Position direction: "long" or "short"
  * @returns percentShift to pass to `commitTrailingStop`
  *
  * @example
  * // LONG: entry=100, originalSL=90, desired newSL=95
- * const shift = slPriceToPercentShift(95, 90, 100); // -5
+ * const shift = slPriceToPercentShift(95, 90, 100, "long"); // -5
+ * // LONG: entry=100, originalSL=90, desired newSL=105 (profit zone)
+ * const shiftProfit = slPriceToPercentShift(105, 90, 100, "long"); // -15
  * await commitTrailingStop("BTCUSDT", shift, currentPrice);
  */
-declare const slPriceToPercentShift: (newStopLossPrice: number, originalStopLossPrice: number, effectivePriceOpen: number) => number;
+declare const slPriceToPercentShift: (newStopLossPrice: number, originalStopLossPrice: number, effectivePriceOpen: number, position: "long" | "short") => number;
 
 /**
  * Convert an absolute take-profit price to a percentShift for `commitTrailingTake`.
  *
  * percentShift = newTpDistancePercent - originalTpDistancePercent
- * where distance = Math.abs((tpPrice - effectivePriceOpen) / effectivePriceOpen * 100)
+ *
+ * The new distance is SIGNED by position direction (mirrors how ClientStrategy
+ * applies the shift): a take-profit moved past the entry produces a negative
+ * distance, so any target price is expressible —
+ * `tpPercentShiftToPrice(tpPriceToPercentShift(x, ...), ...) === x` holds for
+ * targets on both sides of the entry.
+ *
+ * LONG:  newTpDistancePercent = (newTakeProfitPrice - effectivePriceOpen) / effectivePriceOpen * 100
+ * SHORT: newTpDistancePercent = (effectivePriceOpen - newTakeProfitPrice) / effectivePriceOpen * 100
  *
  * @param newTakeProfitPrice - Desired absolute take-profit price
  * @param originalTakeProfitPrice - Original take-profit price from the pending signal
  * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
+ * @param position - Position direction: "long" or "short"
  * @returns percentShift to pass to `commitTrailingTake`
  *
  * @example
  * // LONG: entry=100, originalTP=110, desired newTP=107
- * const shift = tpPriceToPercentShift(107, 110, 100); // -3
+ * const shift = tpPriceToPercentShift(107, 110, 100, "long"); // -3
  * await commitTrailingTake("BTCUSDT", shift, currentPrice);
  */
-declare const tpPriceToPercentShift: (newTakeProfitPrice: number, originalTakeProfitPrice: number, effectivePriceOpen: number) => number;
+declare const tpPriceToPercentShift: (newTakeProfitPrice: number, originalTakeProfitPrice: number, effectivePriceOpen: number, position: "long" | "short") => number;
 
 /**
  * Convert a percentShift for `commitTrailingStop` back to an absolute stop-loss price.
@@ -31228,6 +32783,38 @@ declare class ActionCoreService implements TAction$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Routes a scheduled signal lifecycle event (creation / cancellation) to all registered actions.
+     *
+     * Retrieves action list from strategy schema (IStrategySchema.actions) and invokes the
+     * scheduleEvent handler on each ClientAction instance sequentially. Called once on creation
+     * (action "scheduled") and once on cancellation before activation (action "cancelled").
+     *
+     * @param backtest - Whether running in backtest mode (true) or live mode (false)
+     * @param event - Scheduled lifecycle event data (action discriminates created vs cancelled)
+     * @param context - Strategy execution context with strategyName, exchangeName, frameName
+     */
+    scheduleEvent: (backtest: boolean, event: ScheduleEventContract, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Routes a pending signal lifecycle event (open / close) to all registered actions.
+     *
+     * Retrieves action list from strategy schema (IStrategySchema.actions) and invokes the
+     * pendingEvent handler on each ClientAction instance sequentially. Called once on open
+     * (action "opened") and once on close (action "closed").
+     *
+     * @param backtest - Whether running in backtest mode (true) or live mode (false)
+     * @param event - Pending lifecycle event data (action discriminates opened vs closed)
+     * @param context - Strategy execution context with strategyName, exchangeName, frameName
+     */
+    pendingEvent: (backtest: boolean, event: SignalEventContract, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
     /**
      * Routes active ping event to all registered actions for the strategy.
      *
@@ -31285,7 +32872,7 @@ declare class ActionCoreService implements TAction$1 {
      * @param event - Sync event with action "signal-open" or "signal-close"
      * @param context - Strategy execution context
      */
-    signalSync: (backtest: boolean, event: SignalSyncContract, context: {
+    orderSync: (backtest: boolean, event: OrderSyncContract, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -31298,7 +32885,7 @@ declare class ActionCoreService implements TAction$1 {
      * @param event - Pending-ping event with action "signal-ping"
      * @param context - Strategy execution context
      */
-    orderPing: (backtest: boolean, event: SignalPingContract, context: {
+    orderCheck: (backtest: boolean, event: OrderCheckContract, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -32707,6 +34294,42 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * Delegates to ClientStrategy.createTakeProfit(). The close is deferred and emitted with
+     * closeReason "take_profit" on the next tick()/backtest(). Works out of the execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    createTakeProfit: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * Delegates to ClientStrategy.createStopLoss(). The close is deferred and emitted with
+     * closeReason "stop_loss" on the next tick()/backtest(). Works out of the execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    createStopLoss: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for this iteration.
      *
@@ -33086,6 +34709,19 @@ declare class FrameConnectionService implements IFrame {
      * @returns Configured ClientFrame instance
      */
     getFrame: ((frameName: FrameName) => ClientFrame) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientFrame>;
+    /**
+     * Disposes cached ClientFrame instance(s) so the next getTimeframe call
+     * regenerates timeframes. Without this, ClientFrame's singleshot would keep
+     * the endDate-to-now clamp frozen at the moment of the first run: a
+     * long-running process re-running the same frame would silently backtest
+     * against stale timeframes and never see newly available candles.
+     *
+     * When called without arguments, clears all memoized frames.
+     * Called by Backtest/Walker at strategy start.
+     *
+     * @param frameName - Frame to clear; omit to clear all frames
+     */
+    clear: (frameName?: FrameName) => void;
     /**
      * Retrieves backtest timeframe boundaries for symbol.
      *
@@ -33328,6 +34964,27 @@ declare class ActionProxy implements IPublicAction {
      * @returns Promise resolving to user's pingScheduled() result or null on error
      */
     pingScheduled(event: SchedulePingContract): Promise<any>;
+    /**
+     * Handles scheduled signal lifecycle events with error capture.
+     *
+     * Wraps the user's scheduleEvent() method to catch and log any errors. Called once when a
+     * scheduled signal is created (action "scheduled") and once when it is cancelled before
+     * activation (action "cancelled").
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     * @returns Promise resolving to user's scheduleEvent() result or null on error
+     */
+    scheduleEvent(event: ScheduleEventContract): Promise<any>;
+    /**
+     * Handles pending signal lifecycle events with error capture.
+     *
+     * Wraps the user's pendingEvent() method to catch and log any errors. Called once when a
+     * pending position is opened (action "opened") and once when it is closed (action "closed").
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     * @returns Promise resolving to user's pendingEvent() result or null on error
+     */
+    pendingEvent(event: SignalEventContract): Promise<any>;
     /**
      * Handles active ping events with error capture.
      *
@@ -33364,14 +35021,16 @@ declare class ActionProxy implements IPublicAction {
      *
      * @param event - Sync event with action "signal-open" or "signal-close"
      */
-    signalSync(event: SignalSyncContract): Promise<void>;
+    orderSync(event: OrderSyncContract): Promise<void>;
     /**
-     * Gate for the pending-order ping (order still open on exchange?).
+     * Gate for the order ping (order still open on exchange?). Fires for both
+     * monitored states: event.type "active" (open position order) and "schedule"
+     * (resting entry order of a scheduled signal).
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
      *
-     * @param event - Pending-ping event with action "signal-ping"
+     * @param event - Order-ping event with action "signal-ping" and type "schedule" | "active"
      */
-    orderPing(event: SignalPingContract): Promise<void>;
+    orderCheck(event: OrderCheckContract): Promise<void>;
     /**
      * Cleans up resources with error capture.
      *
@@ -33506,6 +35165,22 @@ declare class ClientAction implements IAction {
      * Handles scheduled ping events during scheduled signal monitoring.
      */
     pingScheduled(event: SchedulePingContract): Promise<void>;
+    /**
+     * Handles scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Manual wiring — EVENT-BASED: users implement {@link IActionCallbacks.onScheduleEvent} (via `addActionSchema`)
+     * to drive the exchange (`commitActivateScheduled` / `commitCancelScheduled`); see that contract
+     * for the full guidance and example. This internal dispatch forwards to the handler/callback.
+     */
+    scheduleEvent(event: ScheduleEventContract): Promise<void>;
+    /**
+     * Handles pending signal lifecycle events (open / close).
+     *
+     * Manual wiring — EVENT-BASED: users implement {@link IActionCallbacks.onPendingEvent} (via `addActionSchema`) to
+     * drive the exchange; for per-tick fills use `onPingActive`. See that contract for the full
+     * guidance and example. This internal dispatch forwards to the handler/callback.
+     */
+    pendingEvent(event: SignalEventContract): Promise<void>;
     /**
      * Handles active ping events during active pending signal monitoring.
      */
@@ -33522,12 +35197,12 @@ declare class ClientAction implements IAction {
      * Gate for position open/close via limit order.
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_FN.
      */
-    signalSync(event: SignalSyncContract): Promise<void>;
+    orderSync(event: OrderSyncContract): Promise<void>;
     /**
      * Gate for the pending-order ping (order still open on exchange?).
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
      */
-    orderPing(event: SignalPingContract): Promise<void>;
+    orderCheck(event: OrderCheckContract): Promise<void>;
     /**
      * Cleans up resources and subscriptions when action handler is no longer needed.
      * Uses singleshot pattern to ensure cleanup happens exactly once.
@@ -33693,6 +35368,32 @@ declare class ActionConnectionService implements TAction {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Routes a scheduled signal lifecycle event (creation / cancellation) to the ClientAction instance.
+     *
+     * @param event - Scheduled lifecycle event data (action discriminates created vs cancelled)
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     */
+    scheduleEvent: (event: ScheduleEventContract, backtest: boolean, context: {
+        actionName: ActionName;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Routes a pending signal lifecycle event (open / close) to the ClientAction instance.
+     *
+     * @param event - Pending lifecycle event data (action discriminates opened vs closed)
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     */
+    pendingEvent: (event: SignalEventContract, backtest: boolean, context: {
+        actionName: ActionName;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
     /**
      * Routes active ping event to appropriate ClientAction instance.
      *
@@ -33733,7 +35434,7 @@ declare class ActionConnectionService implements TAction {
         frameName: FrameName;
     }) => Promise<void>;
     /**
-     * Routes signalSync event to appropriate ClientAction instance.
+     * Routes orderSync event to appropriate ClientAction instance.
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_FN.
      *
      * @param event - Sync event with action "signal-open" or "signal-close"
@@ -33741,21 +35442,21 @@ declare class ActionConnectionService implements TAction {
      * @param context - Execution context
      * @returns true to allow, false to reject
      */
-    signalSync: (event: SignalSyncContract, backtest: boolean, context: {
+    orderSync: (event: OrderSyncContract, backtest: boolean, context: {
         actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
     /**
-     * Routes orderPing event to appropriate ClientAction instance.
+     * Routes orderCheck event to appropriate ClientAction instance.
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
      *
      * @param event - Pending-ping event with action "signal-ping"
      * @param backtest - Whether running in backtest mode
      * @param context - Execution context
      */
-    orderPing: (event: SignalPingContract, backtest: boolean, context: {
+    orderCheck: (event: OrderCheckContract, backtest: boolean, context: {
         actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -34344,6 +36045,44 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * Validates the context, then delegates to StrategyConnectionService.createTakeProfit().
+     * The close is deferred and emitted with closeReason "take_profit" on the next tick/backtest.
+     * 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 payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    createTakeProfit: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * Validates the context, then delegates to StrategyConnectionService.createStopLoss().
+     * The close is deferred and emitted with closeReason "stop_loss" on the next tick/backtest.
+     * 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 payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    createStopLoss: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for this iteration.
      *
@@ -38100,4 +39839,4 @@ declare const getTotalClosed: (signal: Signal) => {
  */
 declare const getPriceScale: (value: number) => number;
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AfterEndContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, type BeforeStartContract, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerSignalPendingPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, type CommitPayload, Constant, type CriticalErrorNotification, Cron, type CronCallback, type CronEntry, type CronHandle, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPersistBreakevenInstance, type IPersistCandleInstance, type IPersistIntervalInstance, type IPersistLogInstance, type IPersistMeasureInstance, type IPersistMemoryInstance, type IPersistNotificationInstance, type IPersistPartialInstance, type IPersistRecentInstance, type IPersistRiskInstance, type IPersistScheduleInstance, type IPersistSessionInstance, type IPersistSignalInstance, type IPersistStateInstance, type IPersistStorageInstance, type IPersistStrategyInstance, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IRecentUtils, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IRuntimeInfo, type IRuntimeRange, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISessionInstance, type ISignalDto, type ISignalIntervalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStateInstance, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type IdlePingContract, type InfoErrorNotification, Interval, type IntervalData, Live, type LiveStatisticsModel, Log, type LogData, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, MarkdownWriter, MaxDrawdown, type MaxDrawdownContract, type MaxDrawdownEvent, type MaxDrawdownStatisticsModel, type MeasureData, Memory, MemoryBacktest, MemoryBacktestAdapter, type MemoryData, MemoryLive, MemoryLiveAdapter, type MessageModel, type MessageRole, type MessageToolCall, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, PersistStrategyAdapter, PersistStrategyInstance, Position, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Recent, RecentBacktest, type RecentData, RecentLive, Reflect, Report, ReportBase, type ReportName, ReportWriter, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, type RuntimeData, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, Session, SessionBacktest, type SessionData, SessionLive, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInfoContract, type SignalInfoNotification, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalPingContract, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, State, StateBacktest, StateBacktestAdapter, type StateData, StateLive, StateLiveAdapter, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyData, type StrategyEvent, type StrategyStatisticsModel, type StrategyStatus, Sync, type SyncEvent, type SyncStatisticsModel, System, type TBrokerCtor, type TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TPersistBreakevenInstanceCtor, type TPersistCandleInstanceCtor, type TPersistIntervalInstanceCtor, type TPersistLogInstanceCtor, type TPersistMeasureInstanceCtor, type TPersistMemoryInstanceCtor, type TPersistNotificationInstanceCtor, type TPersistPartialInstanceCtor, type TPersistRecentInstanceCtor, type TPersistRiskInstanceCtor, type TPersistScheduleInstanceCtor, type TPersistSessionInstanceCtor, type TPersistSignalInstanceCtor, type TPersistStateInstanceCtor, type TPersistStorageInstanceCtor, type TPersistStrategyInstanceCtor, type TRecentUtilsCtor, type TReportBase, type TSessionInstanceCtor, type TStateInstanceCtor, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitCreateSignal, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AfterEndContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, type BeforeStartContract, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerActivePingPayload, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerIdlePingPayload, type BrokerOrderCheckPayload, type BrokerOrderClosePayload, type BrokerOrderOpenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerPendingClosePayload, type BrokerPendingOpenPayload, type BrokerScheduleCancelledPayload, type BrokerScheduleOpenPayload, type BrokerSchedulePingPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, type CommitPayload, Constant, type CriticalErrorNotification, Cron, type CronCallback, type CronEntry, type CronHandle, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPersistBreakevenInstance, type IPersistCandleInstance, type IPersistIntervalInstance, type IPersistLogInstance, type IPersistMeasureInstance, type IPersistMemoryInstance, type IPersistNotificationInstance, type IPersistPartialInstance, type IPersistRecentInstance, type IPersistRiskInstance, type IPersistScheduleInstance, type IPersistSessionInstance, type IPersistSignalInstance, type IPersistStateInstance, type IPersistStorageInstance, type IPersistStrategyInstance, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IRecentUtils, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IRuntimeInfo, type IRuntimeRange, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISessionInstance, type ISignalDto, type ISignalIntervalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStateInstance, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type IdlePingContract, type InfoErrorNotification, Interval, type IntervalData, Live, type LiveStatisticsModel, Log, type LogData, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, MarkdownWriter, MaxDrawdown, type MaxDrawdownContract, type MaxDrawdownEvent, type MaxDrawdownStatisticsModel, type MeasureData, Memory, MemoryBacktest, MemoryBacktestAdapter, type MemoryData, MemoryLive, MemoryLiveAdapter, type MessageModel, type MessageRole, type MessageToolCall, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, type OrderCheckContract, type OrderCloseContract, type OrderOpenContract, type OrderSyncCloseNotification, type OrderSyncContract, type OrderSyncOpenNotification, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, PersistStrategyAdapter, PersistStrategyInstance, Position, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Recent, RecentBacktest, type RecentData, RecentLive, Reflect, Report, ReportBase, type ReportName, ReportWriter, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, type RuntimeData, Schedule, type ScheduleData, type ScheduleEventContract, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, Session, SessionBacktest, type SessionData, SessionLive, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalEventContract, type SignalInfoContract, type SignalInfoNotification, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, State, StateBacktest, StateBacktestAdapter, type StateData, StateLive, StateLiveAdapter, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyData, type StrategyEvent, type StrategyStatisticsModel, type StrategyStatus, Sync, type SyncEvent, type SyncStatisticsModel, System, type TBrokerCtor, type TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TPersistBreakevenInstanceCtor, type TPersistCandleInstanceCtor, type TPersistIntervalInstanceCtor, type TPersistLogInstanceCtor, type TPersistMeasureInstanceCtor, type TPersistMemoryInstanceCtor, type TPersistNotificationInstanceCtor, type TPersistPartialInstanceCtor, type TPersistRecentInstanceCtor, type TPersistRiskInstanceCtor, type TPersistScheduleInstanceCtor, type TPersistSessionInstanceCtor, type TPersistSignalInstanceCtor, type TPersistStateInstanceCtor, type TPersistStorageInstanceCtor, type TPersistStrategyInstanceCtor, type TRecentUtilsCtor, type TReportBase, type TSessionInstanceCtor, type TStateInstanceCtor, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitCreateSignal, commitCreateStopLoss, commitCreateTakeProfit, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getPriceScale, getRawCandles, getRemainingCostBasis, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getTotalPercentHeld, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenCheck, listenCheckOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenScheduleEvent, listenScheduleEventOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalEvent, listenSignalEventOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };