backtest-kit 12.8.0 → 13.1.0

package/build/index.cjs

@@ -1001,6 +1001,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";
@@ -1864,6 +1870,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 = functoolsKit.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.
  *
@@ -6625,6 +6837,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(functoolsKit.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,
@@ -6791,6 +7116,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;
     }
@@ -7088,11 +7416,27 @@ const GET_SIGNAL_FN = functoolsKit.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),
-        functoolsKit.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),
+                functoolsKit.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}`);
     }
@@ -7247,6 +7591,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) {
@@ -7263,6 +7622,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();
@@ -7296,6 +7663,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)
@@ -8920,14 +9311,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);
@@ -9179,7 +9571,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;
@@ -9230,7 +9630,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
@@ -9404,6 +9816,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 = [];
         /**
@@ -9652,7 +10071,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;
     }
@@ -10335,6 +10754,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,
@@ -10393,6 +10814,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,
@@ -10448,6 +10871,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,
@@ -10705,18 +11130,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
@@ -10898,7 +11325,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.
@@ -10942,7 +11369,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
     }
     /**
@@ -10993,7 +11422,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()
     }
     /**
@@ -11038,8 +11469,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.
      *
@@ -11208,10 +11723,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({
@@ -11221,6 +11736,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;
     }
     /**
@@ -11391,10 +11908,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({
@@ -11404,6 +11921,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;
     }
     /**
@@ -11590,10 +12109,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({
@@ -11602,6 +12121,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;
     }
     /**
@@ -11839,10 +12360,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({
@@ -11852,6 +12373,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;
     }
     /**
@@ -12075,10 +12598,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({
@@ -12088,6 +12611,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;
     }
     /**
@@ -12166,10 +12691,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({
@@ -12180,6 +12705,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;
     }
 }
@@ -12326,6 +12853,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).
@@ -12759,7 +13288,7 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = functoolsKit.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,
@@ -13778,6 +14307,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.
@@ -17381,6 +17951,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.
          *
@@ -18905,7 +19516,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}`);
             }
         };
@@ -22920,32 +23531,32 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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
-            ? functoolsKit.str(data.expectedYearlyReturns, "%")
+            ? `${data.expectedYearlyReturns.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -22958,37 +23569,37 @@ const heat_columns = [
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.str(-data.maxDrawdown, "%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? `${(-data.maxDrawdown).toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23012,31 +23623,31 @@ const heat_columns = [
     {
         key: "avgPeakPnl",
         label: "Avg Peak PNL",
-        format: (data) => data.avgPeakPnl !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.str(data.medianPnl, "%") : "N/A",
+        format: (data) => data.medianPnl !== null ? `${data.medianPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23061,7 +23672,7 @@ const heat_columns = [
         key: "avgConsecutiveWinPnl",
         label: "Avg Win Streak PNL",
         format: (data) => data.avgConsecutiveWinPnl !== null
-            ? functoolsKit.str(data.avgConsecutiveWinPnl, "%")
+            ? `${data.avgConsecutiveWinPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23069,7 +23680,7 @@ const heat_columns = [
         key: "avgConsecutiveLossPnl",
         label: "Avg Loss Streak PNL",
         format: (data) => data.avgConsecutiveLossPnl !== null
-            ? functoolsKit.str(data.avgConsecutiveLossPnl, "%")
+            ? `${data.avgConsecutiveLossPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23082,7 +23693,7 @@ const heat_columns = [
     {
         key: "trendStrength",
         label: "Trend %/d",
-        format: (data) => data.trendStrength !== null ? functoolsKit.str(data.trendStrength, "%") : "N/A",
+        format: (data) => data.trendStrength !== null ? `${data.trendStrength.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23135,25 +23746,25 @@ const heat_columns = [
     {
         key: "medianStepSize",
         label: "Median Step",
-        format: (data) => data.medianStepSize !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.str(data.recoveryFactor) : "N/A",
+        format: (data) => data.recoveryFactor !== null ? data.recoveryFactor.toFixed(3) : "N/A",
         isVisible: () => true,
     },
 ];
@@ -30329,28 +30940,28 @@ class HeatmapStorage {
             `# Portfolio Heatmap: ${strategyName}`,
             "",
             `**Total Symbols:** ${data.totalSymbols}`,
-            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"}`,
-            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"}`,
-            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? functoolsKit.str(data.portfolioAnnualizedSharpeRatio) : "N/A"}`,
-            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? functoolsKit.str(data.portfolioCertaintyRatio) : "N/A"}`,
-            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? functoolsKit.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 ? functoolsKit.str(data.portfolioAvgPeakPnl, "%") : "N/A"}`,
-            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? functoolsKit.str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
-            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? functoolsKit.str(data.portfolioPeakProfitPnl, "%") : "N/A"}`,
-            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? functoolsKit.str(data.portfolioMaxDrawdownPnl, "%") : "N/A"}`,
-            `**Median PNL:** ${data.portfolioMedianPnl !== null ? functoolsKit.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 ? functoolsKit.str(data.portfolioAvgConsecutiveWinPnl, "%") : "N/A"}`,
-            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? functoolsKit.str(data.portfolioAvgConsecutiveLossPnl, "%") : "N/A"}`,
-            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? functoolsKit.str(data.portfolioStdDev, "%") : "N/A"}`,
-            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? functoolsKit.str(data.portfolioSortinoRatio) : "N/A"}`,
-            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? functoolsKit.str(data.portfolioCalmarRatio) : "N/A"}`,
-            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? functoolsKit.str(data.portfolioRecoveryFactor) : "N/A"}`,
-            `**Expectancy:** ${data.portfolioExpectancy !== null ? functoolsKit.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,
             "",
@@ -42619,6 +43230,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.
  *
@@ -44683,6 +45296,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";
 /**
@@ -46354,6 +47030,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";
@@ -48058,6 +48736,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).
          *
@@ -49016,6 +49741,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";
@@ -50893,6 +51620,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).
          *
@@ -67539,119 +68321,6 @@ 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(functoolsKit.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;
-};
-
 exports.ActionBase = ActionBase;
 exports.Backtest = Backtest;
 exports.Breakeven = Breakeven;
@@ -67716,6 +68385,8 @@ exports.PersistStateAdapter = PersistStateAdapter;
 exports.PersistStateInstance = PersistStateInstance;
 exports.PersistStorageAdapter = PersistStorageAdapter;
 exports.PersistStorageInstance = PersistStorageInstance;
+exports.PersistStrategyAdapter = PersistStrategyAdapter;
+exports.PersistStrategyInstance = PersistStrategyInstance;
 exports.Position = Position;
 exports.PositionSize = PositionSize;
 exports.Recent = Recent;
@@ -67768,6 +68439,7 @@ exports.commitTrailingStop = commitTrailingStop;
 exports.commitTrailingStopCost = commitTrailingStopCost;
 exports.commitTrailingTake = commitTrailingTake;
 exports.commitTrailingTakeCost = commitTrailingTakeCost;
+exports.createSignal = createSignal;
 exports.createSignalState = createSignalState;
 exports.dumpAgentAnswer = dumpAgentAnswer;
 exports.dumpError = dumpError;
@@ -67842,6 +68514,7 @@ exports.getSessionData = getSessionData;
 exports.getSignalState = getSignalState;
 exports.getSizingSchema = getSizingSchema;
 exports.getStrategySchema = getStrategySchema;
+exports.getStrategyStatus = getStrategyStatus;
 exports.getSymbol = getSymbol;
 exports.getTimestamp = getTimestamp;
 exports.getTotalClosed = getTotalClosed;