backtest-kit 12.8.0 → 13.1.0

package/build/index.mjs

@@ -981,6 +981,12 @@ const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writ
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR = "PersistScheduleUtils.clear";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_PERSIST_STRATEGY_ADAPTER = "PersistStrategyUtils.usePersistStrategyAdapter";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_READ_DATA = "PersistStrategyUtils.readStrategyData";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_WRITE_DATA = "PersistStrategyUtils.writeStrategyData";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_JSON = "PersistStrategyUtils.useJson";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_DUMMY = "PersistStrategyUtils.useDummy";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_CLEAR = "PersistStrategyUtils.clear";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
@@ -1844,6 +1850,212 @@ class PersistScheduleUtils {
  * ```
  */
 const PersistScheduleAdapter = new PersistScheduleUtils();
+/**
+ * Default file-based implementation of IPersistStrategyInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses fixed entity ID "strategy" within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistStrategyInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeStrategyData(snapshot);
+ * const restored = await instance.readStrategyData();
+ * ```
+ */
+class PersistStrategyInstance {
+    /**
+     * Creates new deferred strategy state persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/strategy/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted strategy state snapshot using the fixed STORAGE_KEY.
+     *
+     * @returns Promise resolving to strategy state snapshot or null if not found
+     */
+    async readStrategyData() {
+        if (await this._storage.hasValue(PersistStrategyInstance.STORAGE_KEY)) {
+            const strategyData = await this._storage.readValue(PersistStrategyInstance.STORAGE_KEY);
+            // JSON serializes Infinity as null, so an eternal-hold signal
+            // (minuteEstimatedTime: Infinity) reads back as null — restore it.
+            for (const signal of [strategyData.closedSignal, strategyData.cancelledSignal, strategyData.activatedSignal]) {
+                if (signal && signal.minuteEstimatedTime == null) {
+                    signal.minuteEstimatedTime = Infinity;
+                }
+            }
+            return strategyData;
+        }
+        return null;
+    }
+    /**
+     * Writes the strategy state snapshot (or null to clear) using the fixed STORAGE_KEY.
+     *
+     * @param row - Strategy state snapshot to persist, or null to clear
+     * @returns Promise that resolves when write is complete
+     */
+    async writeStrategyData(row) {
+        await this._storage.writeValue(PersistStrategyInstance.STORAGE_KEY, row);
+    }
+}
+/** Fixed entity key for storing the strategy state snapshot */
+PersistStrategyInstance.STORAGE_KEY = "strategy";
+/**
+ * No-op IPersistStrategyInstance implementation used by PersistStrategyUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistStrategyDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistStrategyInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted strategy state).
+     * @returns Promise resolving to null
+     */
+    async readStrategyData() { return null; }
+    /**
+     * No-op write (discards strategy state).
+     * @returns Promise that resolves immediately
+     */
+    async writeStrategyData(_row) { }
+}
+/**
+ * Utility class for managing deferred strategy state persistence.
+ *
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations for the deferred state snapshot
+ * - Crash-safe in-flight broker operation state management
+ *
+ * Used by ClientStrategy for live mode persistence of the commit queue and deferred
+ * user actions (_commitQueue, _closedSignal, _cancelledSignal, _activatedSignal).
+ */
+class PersistStrategyUtils {
+    constructor() {
+        /**
+         * Constructor used to create per-context strategy state instances.
+         * Replaceable via usePersistStrategyAdapter() / useJson() / useDummy().
+         */
+        this.PersistStrategyInstanceCtor = PersistStrategyInstance;
+        /**
+         * Memoized factory creating one IPersistStrategyInstance per (symbol, strategy, exchange) triple.
+         */
+        this.getStrategyStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistStrategyInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads persisted deferred strategy state for the given context.
+         * Lazily initializes the instance on first access.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to strategy state snapshot or null if none persisted
+         */
+        this.readStrategyData = async (symbol, strategyName, exchangeName) => {
+            LOGGER_SERVICE$9.info(PERSIST_STRATEGY_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getStrategyStorage.has(key);
+            const instance = this.getStrategyStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readStrategyData();
+        };
+        /**
+         * Writes deferred strategy state (or null to clear) for the given context.
+         * Lazily initializes the instance on first access.
+         *
+         * @param strategyRow - Strategy state snapshot to persist, or null to clear
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeStrategyData = async (strategyRow, symbol, strategyName, exchangeName) => {
+            LOGGER_SERVICE$9.info(PERSIST_STRATEGY_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getStrategyStorage.has(key);
+            const instance = this.getStrategyStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeStrategyData(strategyRow);
+        };
+    }
+    /**
+     * Registers a custom IPersistStrategyInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
+     *
+     * @param Ctor - Custom IPersistStrategyInstance constructor
+     */
+    usePersistStrategyAdapter(Ctor) {
+        LOGGER_SERVICE$9.info(PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_PERSIST_STRATEGY_ADAPTER);
+        this.PersistStrategyInstanceCtor = Ctor;
+        this.getStrategyStorage.clear();
+    }
+    /**
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
+     */
+    clear() {
+        LOGGER_SERVICE$9.log(PERSIST_STRATEGY_UTILS_METHOD_NAME_CLEAR);
+        this.getStrategyStorage.clear();
+    }
+    /**
+     * Switches to the default file-based PersistStrategyInstance.
+     */
+    useJson() {
+        LOGGER_SERVICE$9.log(PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistStrategyAdapter(PersistStrategyInstance);
+    }
+    /**
+     * Switches to PersistStrategyDummyInstance (all operations are no-ops).
+     */
+    useDummy() {
+        LOGGER_SERVICE$9.log(PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistStrategyAdapter(PersistStrategyDummyInstance);
+    }
+}
+/**
+ * Global singleton instance of PersistStrategyUtils.
+ * Used by ClientStrategy for deferred strategy state persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistStrategyAdapter.usePersistStrategyAdapter(RedisPersist);
+ *
+ * // Read strategy state
+ * const state = await PersistStrategyAdapter.readStrategyData("BTCUSDT", "my-strategy", "binance");
+ *
+ * // Write strategy state
+ * await PersistStrategyAdapter.writeStrategyData(state, "BTCUSDT", "my-strategy", "binance");
+ * ```
+ */
+const PersistStrategyAdapter = new PersistStrategyUtils();
 /**
  * Default file-based implementation of IPersistPartialInstance.
  *
@@ -6605,6 +6817,119 @@ const validateScheduledSignal = (signal, currentPrice) => {
     }
 };
 
+/**
+ * Validates ISignalDto returned by getSignal, branching on the same logic as ClientStrategy GET_SIGNAL_FN.
+ *
+ * When priceOpen is provided:
+ *   - If currentPrice already reached priceOpen (shouldActivateImmediately) →
+ *     validates as pending: currentPrice must be between SL and TP
+ *   - Otherwise → validates as scheduled: priceOpen must be between SL and TP
+ *
+ * When priceOpen is absent:
+ *   - Validates as pending: currentPrice must be between SL and TP
+ *
+ * Checks:
+ * - currentPrice is a finite positive number
+ * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
+ * - Position-specific immediate-close protection (pending) or activation-close protection (scheduled)
+ *
+ * @param signal - Signal DTO returned by getSignal
+ * @param currentPrice - Current market price at the moment of signal creation
+ * @returns true if signal is valid, false if validation errors were found (errors logged to console.error)
+ */
+const validateSignal = (signal, currentPrice) => {
+    const errors = [];
+    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
+    {
+        if (typeof currentPrice !== "number") {
+            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (!isFinite(currentPrice)) {
+            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (isFinite(currentPrice) && currentPrice <= 0) {
+            errors.push(`currentPrice must be positive, got ${currentPrice}`);
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
+        return false;
+    }
+    try {
+        validateCommonSignal(signal);
+    }
+    catch (error) {
+        console.error(getErrorMessage(error));
+        return false;
+    }
+    // Определяем режим валидации по той же логике что в GET_SIGNAL_FN:
+    // - нет priceOpen → pending (открывается по currentPrice)
+    // - priceOpen задан и уже достигнут (shouldActivateImmediately) → pending
+    // - priceOpen задан и ещё не достигнут → scheduled
+    const hasPriceOpen = signal.priceOpen !== undefined;
+    const shouldActivateImmediately = hasPriceOpen && ((signal.position === "long" && currentPrice <= signal.priceOpen) ||
+        (signal.position === "short" && currentPrice >= signal.priceOpen));
+    const isScheduled = hasPriceOpen && !shouldActivateImmediately;
+    if (isScheduled) {
+        // Scheduled: priceOpen должен быть между SL и TP (активация не даст моментального закрытия)
+        if (signal.position === "long") {
+            if (isFinite(signal.priceOpen)) {
+                if (signal.priceOpen <= signal.priceStopLoss) {
+                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+                }
+                if (signal.priceOpen >= signal.priceTakeProfit) {
+                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would close immediately on activation. This is logically impossible for LONG position.`);
+                }
+            }
+        }
+        if (signal.position === "short") {
+            if (isFinite(signal.priceOpen)) {
+                if (signal.priceOpen >= signal.priceStopLoss) {
+                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+                }
+                if (signal.priceOpen <= signal.priceTakeProfit) {
+                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
+                }
+            }
+        }
+    }
+    else {
+        // Pending: currentPrice должна быть между SL и TP (позиция не закроется сразу после открытия)
+        if (signal.position === "long") {
+            if (isFinite(currentPrice)) {
+                if (currentPrice <= signal.priceStopLoss) {
+                    errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+                }
+                if (currentPrice >= signal.priceTakeProfit) {
+                    errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+                }
+            }
+        }
+        if (signal.position === "short") {
+            if (isFinite(currentPrice)) {
+                if (currentPrice >= signal.priceStopLoss) {
+                    errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+                }
+                if (currentPrice <= signal.priceTakeProfit) {
+                    errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+                }
+            }
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
+    }
+    return !errors.length;
+};
+
 const INTERVAL_MINUTES$8 = {
     "1m": 1,
     "3m": 3,
@@ -6771,6 +7096,9 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
     {
         self._commitQueue = [];
     }
+    // Persist the now-empty queue so a crash after draining does not replay commits
+    // that were already forwarded to the broker on the next restart.
+    await PERSIST_STRATEGY_FN(self);
     if (!self._pendingSignal) {
         return;
     }
@@ -7068,11 +7396,27 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         self._lastSignalTimestamp = alignedTime;
     }
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-    const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
-    const signal = await Promise.race([
-        self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
-        sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
-    ]);
+    // PRIORITY: a user-queued createPending/createScheduled DTO (set out of async-hooks
+    // context) takes precedence over params.getSignal. When present it is consumed once
+    // here — the slot is cleared and the snapshot rewritten — and then flows through the
+    // exact same pipeline (risk check, priceOpen branching, onSignalSync on open) as a
+    // signal returned by getSignal would.
+    let signal;
+    {
+        if (!self._userSignal) {
+            const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
+            signal = await Promise.race([
+                self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
+                sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
+            ]);
+        }
+        if (self._userSignal) {
+            signal = self._userSignal;
+            self._userSignal = null;
+            await PERSIST_STRATEGY_FN(self);
+        }
+        self._userSignal = null;
+    }
     if (typeof signal === "symbol") {
         throw new Error(`Timeout for ${self.params.method.context.strategyName} symbol=${self.params.execution.context.symbol}`);
     }
@@ -7227,6 +7571,21 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
             self._lastPendingId = recentSignal.id;
         }
     }
+    // Read deferred strategy state (commit queue + deferred user actions) so any
+    // confirmed-but-not-yet-forwarded broker operation survives a live crash and is
+    // re-drained on the next tick. Read here, before the pending restore which may
+    // early-return on exchange/strategy mismatch.
+    const strategyData = await PersistStrategyAdapter.readStrategyData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
+    if (strategyData) {
+        // Deferred user actions are restored unconditionally: a deferred close belongs to
+        // an already-cleared _pendingSignal, and cancel/activate belong to the scheduled
+        // signal — none of them are tied to the currently-pending signal's id. A queued
+        // createSignal is a not-yet-consumed signal source and likewise stands on its own.
+        self._userSignal = strategyData.createSignal;
+        self._closedSignal = strategyData.closedSignal;
+        self._cancelledSignal = strategyData.cancelledSignal;
+        self._activatedSignal = strategyData.activatedSignal;
+    }
     // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
     if (pendingSignal) {
@@ -7243,6 +7602,14 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
             pendingSignal.minuteEstimatedTime = Infinity;
         }
         self._pendingSignal = pendingSignal;
+        // Restore the commit queue only if the snapshot belongs to this exact pending
+        // signal (pendingSignalId === restored id). The queue holds confirmed-but-not-yet
+        // forwarded broker ops (average-buy / partial-* / trailing-* / breakeven) that are
+        // always tied to the active position; a mismatch means the snapshot is stale and
+        // the queue is dropped to avoid replaying ops against the wrong position.
+        if (strategyData && strategyData.pendingSignalId === pendingSignal.id) {
+            self._commitQueue = strategyData.commitQueue ?? [];
+        }
         // Call onActive callback for restored signal
         const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
         const currentTime = self.params.execution.context.when.getTime();
@@ -7276,6 +7643,30 @@ const WAIT_FOR_DISPOSE_FN$1 = async (self) => {
     self.params.logger.debug("ClientStrategy dispose");
     await self.params.onDispose(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName, self.params.method.context.frameName, self.params.execution.context.backtest);
 };
+/**
+ * Persists the deferred strategy state snapshot (commit queue + deferred user actions)
+ * to disk in live mode.
+ *
+ * These fields carry confirmed-but-not-yet-forwarded broker operations and survive the
+ * gap between ticks (drained at the start of the next tick). Without persistence a live
+ * crash in that window silently loses the pending broker operation while _pendingSignal
+ * (already mutated and saved) claims it happened. Skipped in backtest mode.
+ *
+ * @param self - ClientStrategy instance
+ */
+const PERSIST_STRATEGY_FN = async (self) => {
+    if (self.params.backtest) {
+        return;
+    }
+    await PersistStrategyAdapter.writeStrategyData({
+        pendingSignalId: self._pendingSignal?.id ?? null,
+        createSignal: self._userSignal,
+        commitQueue: self._commitQueue,
+        closedSignal: self._closedSignal,
+        cancelledSignal: self._cancelledSignal,
+        activatedSignal: self._activatedSignal,
+    }, self.params.symbol, self.params.strategyName, self.params.exchangeName);
+};
 const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice, timestamp) => {
     // Initialize partial array if not present
     if (!signal._partial)
@@ -8900,14 +9291,15 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
 const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, averagePrice, closeTimestamp) => {
     const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, averagePrice, "closed", closedSignal, self);
     if (!syncCloseAllowed) {
-        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+        // Sync close rejected (e.g. broker rejected the order) — keep _closedSignal intact
+        // and return null so the candle loop re-attempts on the next candle. Mirrors live
+        // tick, which keeps _closedSignal and returns idle on a rejected user close,
+        // re-trying on the following tick.
+        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry on next candle", {
             symbol: self.params.execution.context.symbol,
             signalId: closedSignal.id,
         });
-        self._closedSignal = null;
-        self._pendingSignal = closedSignal;
-        throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
-            `Retry backtest() with new candle data.`);
+        return null;
     }
     self._closedSignal = null;
     const publicSignal = TO_PUBLIC_SIGNAL("pending", closedSignal, averagePrice);
@@ -9159,7 +9551,15 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
         }
         // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
         if (self._closedSignal) {
-            return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+            const userCloseResult = await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+            // Sync close accepted — position closed, return. If rejected, _closedSignal is
+            // kept and we skip this candle: live tick returns idle on a rejected user close
+            // (it does NOT fall into the TP/SL or active-monitoring path), so the candle is
+            // skipped here and the close is re-attempted on the next candle.
+            if (userCloseResult) {
+                return userCloseResult;
+            }
+            continue;
         }
         let shouldClose = false;
         let closeReason;
@@ -9210,7 +9610,19 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
             else {
                 closePrice = averagePrice; // time_expired uses VWAP
             }
-            return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
+            const closeResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
+            // Sync close accepted — position closed, return.
+            if (closeResult) {
+                return closeResult;
+            }
+            // Sync close rejected (e.g. broker rejected the order) — _pendingSignal is left
+            // intact (not cleared on rejection). Do NOT return/continue: fall through to the
+            // active-monitoring block below so this candle is processed exactly like live
+            // tick, which runs RETURN_PENDING_SIGNAL_ACTIVE_FN when CLOSE_PENDING_SIGNAL_FN
+            // returns null (updates _peak/_fall, fires active ping / breakeven / partial
+            // callbacks, drains the commit queue). The close is re-attempted on the next
+            // candle; for time_expired this eventually reaches the loop-exhausted close
+            // (which throws if still rejected).
         }
         // Call onPartialProfit/onPartialLoss callbacks during backtest candle processing
         // Calculate percentage of path to TP/SL
@@ -9384,6 +9796,13 @@ class ClientStrategy {
         this._cancelledSignal = null;
         this._closedSignal = null;
         this._activatedSignal = null;
+        /**
+         * User-supplied signal DTO to be consumed by the next GET_SIGNAL_FN tick instead of
+         * params.getSignal. Set via createSignal. When non-null, params.getSignal is NOT called
+         * and the existing pipeline (priceOpen decides pending vs scheduled, onSignalSync on open)
+         * is reused.
+         */
+        this._userSignal = null;
         /** Queue for commit events to be processed in tick()/backtest() with proper timestamp */
         this._commitQueue = [];
         /**
@@ -9632,7 +10051,7 @@ class ClientStrategy {
     async getStopped(symbol) {
         this.params.logger.debug("ClientStrategy getStopped", {
             symbol,
-            strategyName: this.params.method.context.strategyName,
+            strategyName: this.params.strategyName,
         });
         return this._isStopped;
     }
@@ -10315,6 +10734,8 @@ class ClientStrategy {
         if (this._cancelledSignal) {
             const cancelledSignal = this._cancelledSignal;
             this._cancelledSignal = null; // Clear after emitting
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
             this.params.logger.info("ClientStrategy tick: scheduled signal was cancelled", {
                 symbol: this.params.execution.context.symbol,
                 signalId: cancelledSignal.id,
@@ -10373,6 +10794,8 @@ class ClientStrategy {
                 return await RETURN_IDLE_FN(this, currentPrice);
             }
             this._closedSignal = null; // Clear only after sync confirmed
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
             this.params.logger.info("ClientStrategy tick: pending signal was closed", {
                 symbol: this.params.execution.context.symbol,
                 signalId: closedSignal.id,
@@ -10428,6 +10851,8 @@ class ClientStrategy {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
             const activatedSignal = this._activatedSignal;
             this._activatedSignal = null; // Clear after emitting
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
             this.params.logger.info("ClientStrategy tick: scheduled signal was activated", {
                 symbol: this.params.execution.context.symbol,
                 signalId: activatedSignal.id,
@@ -10685,18 +11110,20 @@ class ClientStrategy {
             const currentPrice = await this.params.exchange.getAveragePrice(symbol);
             const closedSignal = this._closedSignal;
             const closeTimestamp = this.params.execution.context.when.getTime();
-            // Sync close: if external system rejects — restore _pendingSignal, retry on next backtest() call
+            // Sync close: if external system rejects — keep the close pending and re-attempt
+            // it inside the candle loop below (PROCESS_PENDING_SIGNAL_CANDLES_FN handles
+            // _closedSignal per candle). Mirrors live tick, which keeps _closedSignal and
+            // retries on the next tick instead of failing.
             const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, currentPrice, "closed", closedSignal, this);
             if (!syncCloseAllowed) {
-                this.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+                this.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry in candle loop", {
                     symbol: this.params.execution.context.symbol,
                     signalId: closedSignal.id,
                 });
-                // Restore _pendingSignal so next backtest() call can process it normally
-                this._closedSignal = null;
+                // Restore _pendingSignal so the candle loop processes the position normally;
+                // _closedSignal is kept so the loop re-attempts the close on each candle.
                 this._pendingSignal = closedSignal;
-                throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
-                    `Retry backtest() with new candle data.`);
+                return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, this._pendingSignal, candles, frameEndTime);
             }
             this._closedSignal = null; // Clear only after sync confirmed
             // Emit commit with correct timestamp from backtest context
@@ -10878,7 +11305,7 @@ class ClientStrategy {
         if (backtest) {
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.strategyName, this.params.exchangeName);
     }
     /**
      * Cancels the scheduled signal without stopping the strategy.
@@ -10922,7 +11349,9 @@ class ClientStrategy {
             // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _cancelledSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted in tick() with correct currentTime
     }
     /**
@@ -10973,7 +11402,9 @@ class ClientStrategy {
             // Commit will be emitted AFTER successful risk check in PROCESS_SCHEDULED_SIGNAL_CANDLES_FN
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _activatedSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted AFTER successful risk check in tick()
     }
     /**
@@ -11018,8 +11449,92 @@ class ClientStrategy {
             return;
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _closedSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted in tick() with correct currentTime
     }
+    /**
+     * Queues a user-supplied signal DTO to be consumed by the next tick instead of
+     * params.getSignal.
+     *
+     * Works OUT of the async-hooks execution context (uses this.params.symbol directly).
+     * priceOpen decides the outcome in the existing pipeline: when omitted the position opens
+     * immediately at currentPrice; when provided the pipeline opens immediately if priceOpen is
+     * already reached, otherwise registers a scheduled (priceOpen-awaiting) signal. On the next
+     * tick GET_SIGNAL_FN consumes _userSignal and runs the normal pipeline, so onSignalSync
+     * delivery is checked by OPEN_NEW_PENDING_SIGNAL_FN exactly as for a getSignal-produced signal.
+     *
+     * Validation (BEFORE any state mutation — a rejected call stores nothing):
+     * - The DTO must pass the intrinsic shape/price checks.
+     * - There must be NO signal already in flight: no active pending signal, no scheduled signal,
+     *   no already-queued createSignal, and no deferred activate/close/cancel awaiting drain.
+     *   Creating a new signal on top of an existing one is rejected.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price (priceOpen fallback for immediate signals)
+     * @param dto - Signal DTO to open (priceOpen optional)
+     * @returns Promise that resolves when the DTO is queued (and persisted in live mode)
+     * @throws {Error} If the DTO is invalid or a signal/deferred action is already in flight
+     */
+    async createSignal(symbol, currentPrice, dto) {
+        this.params.logger.debug("ClientStrategy createSignal", { symbol, currentPrice });
+        // Validate BEFORE mutating state — a bad DTO or a busy strategy must store nothing.
+        // Reuse validateSignal (the canonical getSignal-output validator, branching
+        // pending-vs-scheduled by the same rule as GET_SIGNAL_FN). It forwards to
+        // validateCommonSignal which requires priceOpen and minuteEstimatedTime, so normalize the
+        // DTO to the defaults GET_SIGNAL_FN would apply (priceOpen → currentPrice for an immediate
+        // signal, minuteEstimatedTime → CC_MAX_SIGNAL_LIFETIME_MINUTES). The original dto stored in
+        // _userSignal is left untouched so GET_SIGNAL_FN applies its own defaults on consume.
+        if (!validateSignal({
+            ...dto,
+            priceOpen: dto.priceOpen ?? currentPrice,
+            minuteEstimatedTime: dto.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
+        }, currentPrice)) {
+            throw new Error(`ClientStrategy createSignal: invalid signal DTO for symbol=${symbol}`);
+        }
+        // Reject if any signal is already in flight or any deferred action is awaiting drain.
+        if (this._pendingSignal) {
+            throw new Error(`ClientStrategy createSignal: a pending signal already exists for symbol=${symbol}`);
+        }
+        if (this._scheduledSignal) {
+            throw new Error(`ClientStrategy createSignal: a scheduled signal already exists for symbol=${symbol}`);
+        }
+        if (this._userSignal) {
+            throw new Error(`ClientStrategy createSignal: a signal is already queued for creation for symbol=${symbol}`);
+        }
+        if (this._activatedSignal) {
+            throw new Error(`ClientStrategy createSignal: a scheduled activation is pending for symbol=${symbol}`);
+        }
+        if (this._closedSignal) {
+            throw new Error(`ClientStrategy createSignal: a pending close is awaiting for symbol=${symbol}`);
+        }
+        if (this._cancelledSignal) {
+            throw new Error(`ClientStrategy createSignal: a scheduled cancel is awaiting for symbol=${symbol}`);
+        }
+        this._userSignal = dto;
+        await PERSIST_STRATEGY_FN(this);
+    }
+    /**
+     * Returns the deferred strategy-state snapshot exactly as it would be written to persist on
+     * this iteration: the in-memory _userSignal, _commitQueue and deferred user-action flags,
+     * plus the current pending signal id.
+     *
+     * Synchronous in-memory read (no disk access), so it works OUT of the async-hooks context.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @returns The current StrategyData snapshot held in memory
+     */
+    async getStatus(symbol) {
+        this.params.logger.debug("ClientStrategy getStatus", { symbol });
+        return {
+            pendingSignalId: this._pendingSignal?.id ?? null,
+            createSignal: this._userSignal,
+            commitQueue: this._commitQueue,
+            closedSignal: this._closedSignal,
+            cancelledSignal: this._cancelledSignal,
+            activatedSignal: this._activatedSignal,
+        };
+    }
     /**
      * Validates preconditions for partialProfit without mutating state.
      *
@@ -11188,10 +11703,10 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
+            this.params.callbacks.onWrite(this.params.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11201,6 +11716,8 @@ class ClientStrategy {
             percentToClose,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -11371,10 +11888,10 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
+            this.params.callbacks.onWrite(this.params.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11384,6 +11901,8 @@ class ClientStrategy {
             percentToClose,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -11570,10 +12089,10 @@ class ClientStrategy {
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
             const publicSignal = TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice);
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+            this.params.callbacks.onWrite(this.params.symbol, publicSignal, backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11582,6 +12101,8 @@ class ClientStrategy {
             backtest,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -11819,10 +12340,10 @@ class ClientStrategy {
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
             const publicSignal = TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice);
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+            this.params.callbacks.onWrite(this.params.symbol, publicSignal, backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11832,6 +12353,8 @@ class ClientStrategy {
             percentShift,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -12055,10 +12578,10 @@ class ClientStrategy {
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
             const publicSignal = TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice);
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+            this.params.callbacks.onWrite(this.params.symbol, publicSignal, backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -12068,6 +12591,8 @@ class ClientStrategy {
             percentShift,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -12146,10 +12671,10 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
+            this.params.callbacks.onWrite(this.params.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -12160,6 +12685,8 @@ class ClientStrategy {
             cost,
             totalEntries: this._pendingSignal._entry?.length ?? 1,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
 }
@@ -12306,6 +12833,8 @@ class MergeRisk {
 
 /** Default interval for strategies that do not specify one */
 const STRATEGY_DEFAULT_INTERVAL = "1m";
+/** If not specified strategy will not open positions until createSignal is called manually */
+const STRATEGY_DEFAULT_SIGNAL = () => null;
 /**
  * If syncSubject listener or any registered action throws, it means the signal was not properly synchronized
  * to the exchange (e.g. limit order failed to fill).
@@ -12739,7 +13268,7 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$A(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
-            const { riskName = "", riskList = [], getSignal, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
+            const { riskName = "", riskList = [], getSignal = STRATEGY_DEFAULT_SIGNAL, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
                 interval,
@@ -13758,6 +14287,47 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.closePending(symbol, backtest, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next tick instead of getSignal.
+         *
+         * Delegates to ClientStrategy.createSignal(). Validated and rejected if a signal/deferred
+         * action is already in flight. Works out of the async-hooks execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param dto - Signal DTO to open
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.createSignal = async (backtest, symbol, dto, context) => {
+            this.loggerService.log("strategyConnectionService createSignal", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            await strategy.createSignal(symbol, currentPrice, dto);
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for this iteration.
+         *
+         * Delegates to ClientStrategy.getStatus(). Synchronous in-memory read; works out of context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to the current StrategyData snapshot
+         */
+        this.getStatus = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getStatus", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getStatus(symbol);
+        };
         /**
          * Checks whether `partialProfit` would succeed without executing it.
          * Delegates to `ClientStrategy.validatePartialProfit()` — no throws, pure boolean result.
@@ -17361,6 +17931,47 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.closePending(backtest, symbol, context, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next tick instead of getSignal.
+         *
+         * Validates the context, then delegates to StrategyConnectionService.createSignal().
+         * Rejected if a signal or deferred action is already in flight. Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param dto - Signal DTO to open
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.createSignal = async (backtest, symbol, dto, context) => {
+            this.loggerService.log("strategyCoreService createSignal", {
+                symbol,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.createSignal(backtest, symbol, dto, context);
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for this iteration.
+         *
+         * Validates the context, then delegates to StrategyConnectionService.getStatus().
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to the current StrategyStatus snapshot
+         */
+        this.getStatus = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getStatus", {
+                symbol,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getStatus(backtest, symbol, context);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -18885,7 +19496,7 @@ class StrategySchemaService {
             if (strategySchema.interval && typeof strategySchema.interval !== "string") {
                 throw new Error(`strategy schema validation failed: invalid interval for strategyName=${strategySchema.strategyName}`);
             }
-            if (typeof strategySchema.getSignal !== "function") {
+            if (strategySchema.getSignal && typeof strategySchema.getSignal !== "function") {
                 throw new Error(`strategy schema validation failed: missing getSignal for strategyName=${strategySchema.strategyName}`);
             }
         };
@@ -22900,32 +23511,32 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? str(data.totalPnl, "%") : "N/A",
+        format: (data) => data.totalPnl !== null ? `${data.totalPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "sharpeRatio",
         label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio) : "N/A",
+        format: (data) => data.sharpeRatio !== null ? data.sharpeRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "annualizedSharpeRatio",
         label: "Ann Sharpe",
-        format: (data) => data.annualizedSharpeRatio !== null ? str(data.annualizedSharpeRatio) : "N/A",
+        format: (data) => data.annualizedSharpeRatio !== null ? data.annualizedSharpeRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "certaintyRatio",
         label: "Certainty",
-        format: (data) => data.certaintyRatio !== null ? str(data.certaintyRatio) : "N/A",
+        format: (data) => data.certaintyRatio !== null ? data.certaintyRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectedYearlyReturns",
         label: "Exp Yearly",
         format: (data) => data.expectedYearlyReturns !== null
-            ? str(data.expectedYearlyReturns, "%")
+            ? `${data.expectedYearlyReturns.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -22938,37 +23549,37 @@ const heat_columns = [
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? str(data.profitFactor) : "N/A",
+        format: (data) => data.profitFactor !== null ? data.profitFactor.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectancy",
         label: "Expect",
-        format: (data) => data.expectancy !== null ? str(data.expectancy, "%") : "N/A",
+        format: (data) => data.expectancy !== null ? `${data.expectancy.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "winRate",
         label: "WR",
-        format: (data) => data.winRate !== null ? str(data.winRate, "%") : "N/A",
+        format: (data) => data.winRate !== null ? `${data.winRate.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgWin",
         label: "Avg Win",
-        format: (data) => data.avgWin !== null ? str(data.avgWin, "%") : "N/A",
+        format: (data) => data.avgWin !== null ? `${data.avgWin.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgLoss",
         label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%") : "N/A",
+        format: (data) => data.avgLoss !== null ? `${data.avgLoss.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdown",
         label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? `${(-data.maxDrawdown).toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -22992,31 +23603,31 @@ const heat_columns = [
     {
         key: "avgPeakPnl",
         label: "Avg Peak PNL",
-        format: (data) => data.avgPeakPnl !== null ? str(data.avgPeakPnl, "%") : "N/A",
+        format: (data) => data.avgPeakPnl !== null ? `${data.avgPeakPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgFallPnl",
         label: "Avg DD PNL",
-        format: (data) => data.avgFallPnl !== null ? str(data.avgFallPnl, "%") : "N/A",
+        format: (data) => data.avgFallPnl !== null ? `${data.avgFallPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "peakProfitPnl",
         label: "Peak Profit PNL",
-        format: (data) => data.peakProfitPnl !== null ? str(data.peakProfitPnl, "%") : "N/A",
+        format: (data) => data.peakProfitPnl !== null ? `${data.peakProfitPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdownPnl",
         label: "Max DD PNL",
-        format: (data) => data.maxDrawdownPnl !== null ? str(data.maxDrawdownPnl, "%") : "N/A",
+        format: (data) => data.maxDrawdownPnl !== null ? `${data.maxDrawdownPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "medianPnl",
         label: "Median PNL",
-        format: (data) => data.medianPnl !== null ? str(data.medianPnl, "%") : "N/A",
+        format: (data) => data.medianPnl !== null ? `${data.medianPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23041,7 +23652,7 @@ const heat_columns = [
         key: "avgConsecutiveWinPnl",
         label: "Avg Win Streak PNL",
         format: (data) => data.avgConsecutiveWinPnl !== null
-            ? str(data.avgConsecutiveWinPnl, "%")
+            ? `${data.avgConsecutiveWinPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23049,7 +23660,7 @@ const heat_columns = [
         key: "avgConsecutiveLossPnl",
         label: "Avg Loss Streak PNL",
         format: (data) => data.avgConsecutiveLossPnl !== null
-            ? str(data.avgConsecutiveLossPnl, "%")
+            ? `${data.avgConsecutiveLossPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23062,7 +23673,7 @@ const heat_columns = [
     {
         key: "trendStrength",
         label: "Trend %/d",
-        format: (data) => data.trendStrength !== null ? str(data.trendStrength, "%") : "N/A",
+        format: (data) => data.trendStrength !== null ? `${data.trendStrength.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23115,25 +23726,25 @@ const heat_columns = [
     {
         key: "medianStepSize",
         label: "Median Step",
-        format: (data) => data.medianStepSize !== null ? str(data.medianStepSize, "%") : "N/A",
+        format: (data) => data.medianStepSize !== null ? `${data.medianStepSize.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "sortinoRatio",
         label: "Sortino",
-        format: (data) => data.sortinoRatio !== null ? str(data.sortinoRatio) : "N/A",
+        format: (data) => data.sortinoRatio !== null ? data.sortinoRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "calmarRatio",
         label: "Calmar",
-        format: (data) => data.calmarRatio !== null ? str(data.calmarRatio) : "N/A",
+        format: (data) => data.calmarRatio !== null ? data.calmarRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "recoveryFactor",
         label: "Recovery",
-        format: (data) => data.recoveryFactor !== null ? str(data.recoveryFactor) : "N/A",
+        format: (data) => data.recoveryFactor !== null ? data.recoveryFactor.toFixed(3) : "N/A",
         isVisible: () => true,
     },
 ];
@@ -30309,28 +30920,28 @@ class HeatmapStorage {
             `# Portfolio Heatmap: ${strategyName}`,
             "",
             `**Total Symbols:** ${data.totalSymbols}`,
-            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"}`,
-            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"}`,
-            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? str(data.portfolioAnnualizedSharpeRatio) : "N/A"}`,
-            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? str(data.portfolioCertaintyRatio) : "N/A"}`,
-            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? str(data.portfolioExpectedYearlyReturns, "%") : "N/A"}`,
+            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? `${data.portfolioTotalPnl.toFixed(2)} %` : "N/A"}`,
+            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? data.portfolioSharpeRatio.toFixed(3) : "N/A"}`,
+            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? data.portfolioAnnualizedSharpeRatio.toFixed(3) : "N/A"}`,
+            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? data.portfolioCertaintyRatio.toFixed(3) : "N/A"}`,
+            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? `${data.portfolioExpectedYearlyReturns.toFixed(2)} %` : "N/A"}`,
             `**Trades Per Year:** ${data.portfolioTradesPerYear !== null ? data.portfolioTradesPerYear.toFixed(1) : "N/A"}`,
             `**Total Trades:** ${data.portfolioTotalTrades}`,
-            `**Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"}`,
-            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
-            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? str(data.portfolioPeakProfitPnl, "%") : "N/A"}`,
-            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? str(data.portfolioMaxDrawdownPnl, "%") : "N/A"}`,
-            `**Median PNL:** ${data.portfolioMedianPnl !== null ? str(data.portfolioMedianPnl, "%") : "N/A"}`,
+            `**Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? `${data.portfolioAvgPeakPnl.toFixed(2)} %` : "N/A"}`,
+            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? `${data.portfolioAvgFallPnl.toFixed(2)} %` : "N/A"}`,
+            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? `${data.portfolioPeakProfitPnl.toFixed(2)} %` : "N/A"}`,
+            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? `${data.portfolioMaxDrawdownPnl.toFixed(2)} %` : "N/A"}`,
+            `**Median PNL:** ${data.portfolioMedianPnl !== null ? `${data.portfolioMedianPnl.toFixed(2)} %` : "N/A"}`,
             `**Avg Duration:** ${data.portfolioAvgDuration !== null ? `${data.portfolioAvgDuration.toFixed(1)} min` : "N/A"}`,
             `**Avg Win Duration:** ${data.portfolioAvgWinDuration !== null ? `${data.portfolioAvgWinDuration.toFixed(1)} min` : "N/A"}`,
             `**Avg Loss Duration:** ${data.portfolioAvgLossDuration !== null ? `${data.portfolioAvgLossDuration.toFixed(1)} min` : "N/A"}`,
-            `**Avg Consecutive Win PNL:** ${data.portfolioAvgConsecutiveWinPnl !== null ? str(data.portfolioAvgConsecutiveWinPnl, "%") : "N/A"}`,
-            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? str(data.portfolioAvgConsecutiveLossPnl, "%") : "N/A"}`,
-            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? str(data.portfolioStdDev, "%") : "N/A"}`,
-            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? str(data.portfolioSortinoRatio) : "N/A"}`,
-            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? str(data.portfolioCalmarRatio) : "N/A"}`,
-            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? str(data.portfolioRecoveryFactor) : "N/A"}`,
-            `**Expectancy:** ${data.portfolioExpectancy !== null ? str(data.portfolioExpectancy, "%") : "N/A"}`,
+            `**Avg Consecutive Win PNL:** ${data.portfolioAvgConsecutiveWinPnl !== null ? `${data.portfolioAvgConsecutiveWinPnl.toFixed(2)} %` : "N/A"}`,
+            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? `${data.portfolioAvgConsecutiveLossPnl.toFixed(2)} %` : "N/A"}`,
+            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? `${data.portfolioStdDev.toFixed(2)} %` : "N/A"}`,
+            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? data.portfolioSortinoRatio.toFixed(3) : "N/A"}`,
+            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? data.portfolioCalmarRatio.toFixed(3) : "N/A"}`,
+            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? data.portfolioRecoveryFactor.toFixed(3) : "N/A"}`,
+            `**Expectancy:** ${data.portfolioExpectancy !== null ? `${data.portfolioExpectancy.toFixed(2)} %` : "N/A"}`,
             "",
             table,
             "",
@@ -42599,6 +43210,8 @@ const GET_POSITION_PARTIAL_OVERLAP_METHOD_NAME = "strategy.getPositionPartialOve
 const HAS_NO_PENDING_SIGNAL_METHOD_NAME = "strategy.hasNoPendingSignal";
 const HAS_NO_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.hasNoScheduledSignal";
 const COMMIT_SIGNAL_NOTIFY_METHOD_NAME = "strategy.commitSignalNotify";
+const CREATE_SIGNAL_METHOD_NAME = "strategy.createSignal";
+const GET_STRATEGY_STATUS_METHOD_NAME = "strategy.getStrategyStatus";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -44663,6 +45276,69 @@ async function commitSignalNotify(symbol, payload = {}) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     await bt.notificationHelperService.commitSignalNotify(payload, symbol, currentPrice, { strategyName, exchangeName, frameName }, isBacktest);
 }
+/**
+ * Queues a user-supplied signal DTO to be consumed by the next tick instead of params.getSignal.
+ *
+ * priceOpen decides the outcome via the existing pipeline: omitted → opens immediately at the
+ * current price; provided → opens immediately if already reached, otherwise registers a
+ * scheduled (priceOpen-awaiting) signal. The DTO is validated (reusing validateSignal) and the
+ * call is rejected if a signal or deferred action is already in flight.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param dto - Signal DTO to open (priceOpen optional)
+ * @returns Promise that resolves when the DTO is queued
+ *
+ * @example
+ * ```typescript
+ * import { createSignal } from "backtest-kit";
+ *
+ * // Open immediately at current price
+ * await createSignal("BTCUSDT", { position: "long", priceTakeProfit: 110, priceStopLoss: 90 });
+ * ```
+ */
+async function createSignal(symbol, dto) {
+    bt.loggerService.info(CREATE_SIGNAL_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("createSignal requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("createSignal requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.createSignal(isBacktest, symbol, dto, { exchangeName, frameName, strategyName });
+}
+/**
+ * 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.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to the current StrategyStatus snapshot
+ *
+ * @example
+ * ```typescript
+ * import { getStrategyStatus } from "backtest-kit";
+ *
+ * const status = await getStrategyStatus("BTCUSDT");
+ * console.log(status.pendingSignalId, status.commitQueue.length);
+ * ```
+ */
+async function getStrategyStatus(symbol) {
+    bt.loggerService.info(GET_STRATEGY_STATUS_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getStrategyStatus requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getStrategyStatus requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getStatus(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -46334,6 +47010,8 @@ const BACKTEST_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "BacktestUtils.getPosi
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
 const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
 const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
+const BACKTEST_METHOD_NAME_CREATE_SIGNAL = "Backtest.createSignal";
+const BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS = "Backtest.getStrategyStatus";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST = "BacktestUtils.commitPartialProfitCost";
@@ -48038,6 +48716,53 @@ class BacktestUtils {
             }
             await bt.strategyCoreService.closePending(true, symbol, context, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next backtest tick instead of
+         * params.getSignal.
+         *
+         * priceOpen decides the outcome via the existing pipeline: omitted → opens immediately at the
+         * current price; provided → opens immediately if already reached, otherwise registers a
+         * scheduled signal. Validated, and rejected if a signal or deferred action is already in flight.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param dto - Signal DTO to open (priceOpen optional)
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.createSignal = async (symbol, context, dto) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CREATE_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CREATE_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CREATE_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CREATE_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CREATE_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CREATE_SIGNAL));
+            }
+            await bt.strategyCoreService.createSignal(true, symbol, dto, context);
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for the current backtest iteration.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise resolving to the current StrategyStatus snapshot
+         */
+        this.getStrategyStatus = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS);
+            return await bt.strategyCoreService.getStatus(true, symbol, context);
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -48996,6 +49721,8 @@ const LIVE_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "LiveUtils.getPositionPart
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
 const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
 const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
+const LIVE_METHOD_NAME_CREATE_SIGNAL = "Live.createSignal";
+const LIVE_METHOD_NAME_GET_STRATEGY_STATUS = "Live.getStrategyStatus";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT_COST = "LiveUtils.commitPartialProfitCost";
@@ -50873,6 +51600,61 @@ class LiveUtils {
                 frameName: "",
             }, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next live tick instead of
+         * params.getSignal.
+         *
+         * priceOpen decides the outcome via the existing pipeline: omitted → opens immediately at the
+         * current price; provided → opens immediately if already reached, otherwise registers a
+         * scheduled signal. Validated, and rejected if a signal or deferred action is already in flight.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param dto - Signal DTO to open (priceOpen optional)
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.createSignal = async (symbol, context, dto) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CREATE_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CREATE_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CREATE_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CREATE_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CREATE_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CREATE_SIGNAL));
+            }
+            await bt.strategyCoreService.createSignal(false, symbol, dto, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for the current live iteration.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise resolving to the current StrategyStatus snapshot
+         */
+        this.getStrategyStatus = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_STRATEGY_STATUS, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_STRATEGY_STATUS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_STRATEGY_STATUS);
+            return await bt.strategyCoreService.getStatus(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -67519,117 +68301,4 @@ const percentValue = (yesterdayValue, todayValue) => {
     return yesterdayValue / todayValue - 1;
 };
 
-/**
- * Validates ISignalDto returned by getSignal, branching on the same logic as ClientStrategy GET_SIGNAL_FN.
- *
- * When priceOpen is provided:
- *   - If currentPrice already reached priceOpen (shouldActivateImmediately) →
- *     validates as pending: currentPrice must be between SL and TP
- *   - Otherwise → validates as scheduled: priceOpen must be between SL and TP
- *
- * When priceOpen is absent:
- *   - Validates as pending: currentPrice must be between SL and TP
- *
- * Checks:
- * - currentPrice is a finite positive number
- * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
- * - Position-specific immediate-close protection (pending) or activation-close protection (scheduled)
- *
- * @param signal - Signal DTO returned by getSignal
- * @param currentPrice - Current market price at the moment of signal creation
- * @returns true if signal is valid, false if validation errors were found (errors logged to console.error)
- */
-const validateSignal = (signal, currentPrice) => {
-    const errors = [];
-    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
-    {
-        if (typeof currentPrice !== "number") {
-            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
-        }
-        if (!isFinite(currentPrice)) {
-            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
-        }
-        if (isFinite(currentPrice) && currentPrice <= 0) {
-            errors.push(`currentPrice must be positive, got ${currentPrice}`);
-        }
-    }
-    if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
-        return false;
-    }
-    try {
-        validateCommonSignal(signal);
-    }
-    catch (error) {
-        console.error(getErrorMessage(error));
-        return false;
-    }
-    // Определяем режим валидации по той же логике что в GET_SIGNAL_FN:
-    // - нет priceOpen → pending (открывается по currentPrice)
-    // - priceOpen задан и уже достигнут (shouldActivateImmediately) → pending
-    // - priceOpen задан и ещё не достигнут → scheduled
-    const hasPriceOpen = signal.priceOpen !== undefined;
-    const shouldActivateImmediately = hasPriceOpen && ((signal.position === "long" && currentPrice <= signal.priceOpen) ||
-        (signal.position === "short" && currentPrice >= signal.priceOpen));
-    const isScheduled = hasPriceOpen && !shouldActivateImmediately;
-    if (isScheduled) {
-        // Scheduled: priceOpen должен быть между SL и TP (активация не даст моментального закрытия)
-        if (signal.position === "long") {
-            if (isFinite(signal.priceOpen)) {
-                if (signal.priceOpen <= signal.priceStopLoss) {
-                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
-                }
-                if (signal.priceOpen >= signal.priceTakeProfit) {
-                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would close immediately on activation. This is logically impossible for LONG position.`);
-                }
-            }
-        }
-        if (signal.position === "short") {
-            if (isFinite(signal.priceOpen)) {
-                if (signal.priceOpen >= signal.priceStopLoss) {
-                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
-                }
-                if (signal.priceOpen <= signal.priceTakeProfit) {
-                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
-                }
-            }
-        }
-    }
-    else {
-        // Pending: currentPrice должна быть между SL и TP (позиция не закроется сразу после открытия)
-        if (signal.position === "long") {
-            if (isFinite(currentPrice)) {
-                if (currentPrice <= signal.priceStopLoss) {
-                    errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
-                }
-                if (currentPrice >= signal.priceTakeProfit) {
-                    errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
-                }
-            }
-        }
-        if (signal.position === "short") {
-            if (isFinite(currentPrice)) {
-                if (currentPrice >= signal.priceStopLoss) {
-                    errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
-                }
-                if (currentPrice <= signal.priceTakeProfit) {
-                    errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
-                }
-            }
-        }
-    }
-    if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
-    }
-    return !errors.length;
-};
-
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, 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, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, 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, 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, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, 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, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignal, 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 };