backtest-kit 2.0.12 → 2.1.1

package/build/index.cjs

@@ -4410,6 +4410,7 @@ class ClientStrategy {
         this._lastSignalTimestamp = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
+        this._closedSignal = null;
         /**
          * Initializes strategy state by loading persisted signal from disk.
          *
@@ -4686,6 +4687,41 @@ class ClientStrategy {
                 reason: "user",
                 cancelId: cancelledSignal.cancelId,
             };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
+            return result;
+        }
+        // Check if pending signal was closed - emit closed event once
+        if (this._closedSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const closedSignal = this._closedSignal;
+            this._closedSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: pending signal was closed", {
+                symbol: this.params.execution.context.symbol,
+                signalId: closedSignal.id,
+            });
+            // Call onClose callback
+            await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+            await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+            await CALL_BREAKEVEN_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
+            const pnl = toProfitLossDto(closedSignal, currentPrice);
+            const result = {
+                action: "closed",
+                signal: TO_PUBLIC_SIGNAL(closedSignal),
+                currentPrice,
+                closeReason: "closed",
+                closeTimestamp: currentTime,
+                pnl,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                backtest: this.params.execution.context.backtest,
+                closeId: closedSignal.closeId,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
         // Monitor scheduled signal
@@ -4799,8 +4835,40 @@ class ClientStrategy {
                 reason: "user",
                 cancelId: cancelledSignal.cancelId,
             };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledResult, closeTimestamp, this.params.execution.context.backtest);
             return cancelledResult;
         }
+        // If signal was closed - return closed
+        if (this._closedSignal) {
+            this.params.logger.debug("ClientStrategy backtest: pending signal was closed");
+            const currentPrice = await this.params.exchange.getAveragePrice(symbol);
+            const closedSignal = this._closedSignal;
+            this._closedSignal = null; // Clear after using
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+            await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+            await CALL_BREAKEVEN_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, closeTimestamp, this.params.execution.context.backtest);
+            const pnl = toProfitLossDto(closedSignal, currentPrice);
+            const closedResult = {
+                action: "closed",
+                signal: TO_PUBLIC_SIGNAL(closedSignal),
+                currentPrice,
+                closeReason: "closed",
+                closeTimestamp: closeTimestamp,
+                pnl,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                backtest: true,
+                closeId: closedSignal.closeId,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, closedResult, closeTimestamp, this.params.execution.context.backtest);
+            return closedResult;
+        }
         if (!this._pendingSignal && !this._scheduledSignal) {
             throw new Error("ClientStrategy backtest: no pending or scheduled signal");
         }
@@ -4927,12 +4995,12 @@ class ClientStrategy {
      * @example
      * ```typescript
      * // In Live.background() cancellation
-     * await strategy.stop();
+     * await strategy.stopStrategy();
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, backtest) {
-        this.params.logger.debug("ClientStrategy stop", {
+    async stopStrategy(symbol, backtest) {
+        this.params.logger.debug("ClientStrategy stopStrategy", {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
@@ -4965,12 +5033,12 @@ class ClientStrategy {
      * @example
      * ```typescript
      * // Cancel scheduled signal without stopping strategy
-     * await strategy.cancel("BTCUSDT", "my-strategy", false);
+     * await strategy.cancelScheduled("BTCUSDT", "my-strategy", false);
      * // Strategy continues, can generate new signals
      * ```
      */
-    async cancel(symbol, backtest, cancelId) {
-        this.params.logger.debug("ClientStrategy cancel", {
+    async cancelScheduled(symbol, backtest, cancelId) {
+        this.params.logger.debug("ClientStrategy cancelScheduled", {
             symbol,
             hasScheduledSignal: this._scheduledSignal !== null,
             cancelId,
@@ -4987,6 +5055,45 @@ class ClientStrategy {
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
     }
+    /**
+     * Closes the pending signal without stopping the strategy.
+     *
+     * Clears the pending signal (active position).
+     * Does NOT affect scheduled signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: Close an active position that is no longer desired without stopping the entire strategy.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param closeId - Optional identifier for this close operation
+     * @returns Promise that resolves when pending signal is cleared
+     *
+     * @example
+     * ```typescript
+     * // Close pending signal without stopping strategy
+     * await strategy.closePending("BTCUSDT", false, "user-close-123");
+     * // Strategy continues, can generate new signals
+     * ```
+     */
+    async closePending(symbol, backtest, closeId) {
+        this.params.logger.debug("ClientStrategy closePending", {
+            symbol,
+            hasPendingSignal: this._pendingSignal !== null,
+            closeId,
+        });
+        // Save closed signal for next tick to emit closed event
+        if (this._pendingSignal) {
+            this._closedSignal = Object.assign({}, this._pendingSignal, {
+                closeId,
+            });
+            this._pendingSignal = null;
+        }
+        if (backtest) {
+            return;
+        }
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+    }
     /**
      * Executes partial close at profit level (moving toward TP).
      *
@@ -6439,7 +6546,7 @@ class StrategyConnectionService {
         /**
          * Stops the specified strategy from generating new signals.
          *
-         * Delegates to ClientStrategy.stop() which sets internal flag to prevent
+         * Delegates to ClientStrategy.stopStrategy() which sets internal flag to prevent
          * getSignal from being called on subsequent ticks.
          *
          * @param backtest - Whether running in backtest mode
@@ -6447,13 +6554,13 @@ class StrategyConnectionService {
          * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyConnectionService stop", {
+        this.stopStrategy = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService stopStrategy", {
                 symbol,
                 context,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.stop(symbol, backtest);
+            await strategy.stopStrategy(symbol, backtest);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -6505,7 +6612,7 @@ class StrategyConnectionService {
         /**
          * Cancels the scheduled signal for the specified strategy.
          *
-         * Delegates to ClientStrategy.cancel() which clears the scheduled signal
+         * Delegates to ClientStrategy.cancelScheduled() which clears the scheduled signal
          * without stopping the strategy or affecting pending signals.
          *
          * Note: Cancelled event will be emitted on next tick() call when strategy
@@ -6517,14 +6624,39 @@ class StrategyConnectionService {
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyConnectionService cancel", {
+        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyConnectionService cancelScheduled", {
                 symbol,
                 context,
                 cancelId,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.cancel(symbol, backtest, cancelId);
+            await strategy.cancelScheduled(symbol, backtest, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * Note: Closed event will be emitted on next tick() call when strategy
+         * detects the pending signal was closed.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         */
+        this.closePending = async (backtest, symbol, context, closeId) => {
+            this.loggerService.log("strategyConnectionService closePending", {
+                symbol,
+                context,
+                closeId,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.closePending(symbol, backtest, closeId);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -9711,19 +9843,19 @@ class StrategyCoreService {
          * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyCoreService stop", {
+        this.stopStrategy = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService stopStrategy", {
                 symbol,
                 context,
                 backtest,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.stop(backtest, symbol, context);
+            return await this.strategyConnectionService.stopStrategy(backtest, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
          *
-         * Delegates to StrategyConnectionService.cancel() to clear scheduled signal
+         * Delegates to StrategyConnectionService.cancelScheduled() to clear scheduled signal
          * and emit cancelled event through emitters.
          * Does not require execution context.
          *
@@ -9733,15 +9865,42 @@ class StrategyCoreService {
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyCoreService cancel", {
+        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyCoreService cancelScheduled", {
                 symbol,
                 context,
                 backtest,
                 cancelId,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.cancel(backtest, symbol, context, cancelId);
+            return await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * Delegates to StrategyConnectionService.closePending() to clear pending signal
+         * and emit closed event through emitters.
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         */
+        this.closePending = async (backtest, symbol, context, closeId) => {
+            this.loggerService.log("strategyCoreService closePending", {
+                symbol,
+                context,
+                backtest,
+                closeId,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.closePending(backtest, symbol, context, closeId);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -25027,7 +25186,8 @@ async function getOrderBook(symbol, depth) {
     return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
 }
 
-const CANCEL_METHOD_NAME = "strategy.commitCancel";
+const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
+const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.commitPartialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
@@ -25049,26 +25209,62 @@ const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
  *
  * @example
  * ```typescript
- * import { cancel } from "backtest-kit";
+ * import { commitCancelScheduled } from "backtest-kit";
  *
  * // Cancel scheduled signal with custom ID
- * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+ * await commitCancelScheduled("BTCUSDT", "manual-cancel-001");
  * ```
  */
-async function commitCancel(symbol, cancelId) {
-    bt.loggerService.info(CANCEL_METHOD_NAME, {
+async function commitCancelScheduled(symbol, cancelId) {
+    bt.loggerService.info(CANCEL_SCHEDULED_METHOD_NAME, {
         symbol,
         cancelId,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("cancel requires an execution context");
+        throw new Error("commitCancelScheduled requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitCancelScheduled requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.cancelScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+}
+/**
+ * Closes the pending signal without stopping the strategy.
+ *
+ * Clears the pending signal (active position).
+ * Does NOT affect scheduled signals or strategy operation.
+ * Does NOT set stop flag - strategy can continue generating new signals.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param closeId - Optional close ID for tracking user-initiated closes
+ * @returns Promise that resolves when pending signal is closed
+ *
+ * @example
+ * ```typescript
+ * import { commitClosePending } from "backtest-kit";
+ *
+ * // Close pending signal with custom ID
+ * await commitClosePending("BTCUSDT", "manual-close-001");
+ * ```
+ */
+async function commitClosePending(symbol, closeId) {
+    bt.loggerService.info(CLOSE_PENDING_METHOD_NAME, {
+        symbol,
+        closeId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitClosePending requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("cancel requires a method context");
+        throw new Error("commitClosePending requires a method context");
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.cancel(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+    await bt.strategyCoreService.closePending(isBacktest, symbol, { exchangeName, frameName, strategyName }, closeId);
 }
 /**
  * Executes partial close at profit level (moving toward TP).
@@ -25315,7 +25511,7 @@ async function commitBreakeven(symbol) {
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
 
-const STOP_METHOD_NAME = "control.stop";
+const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
  * Stops the strategy from generating new signals.
  *
@@ -25337,8 +25533,8 @@ const STOP_METHOD_NAME = "control.stop";
  * await stop("BTCUSDT", "my-strategy");
  * ```
  */
-async function stop(symbol) {
-    bt.loggerService.info(STOP_METHOD_NAME, {
+async function stopStrategy(symbol) {
+    bt.loggerService.info(STOP_STRATEGY_METHOD_NAME, {
         symbol,
     });
     if (!ExecutionContextService.hasContext()) {
@@ -25349,7 +25545,7 @@ async function stop(symbol) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.stop(isBacktest, symbol, {
+    await bt.strategyCoreService.stopStrategy(isBacktest, symbol, {
         exchangeName,
         frameName,
         strategyName,
@@ -27736,7 +27932,8 @@ const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal"
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
-const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.commitCancel";
+const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
+const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
@@ -27978,7 +28175,7 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(true, symbol, {
+                bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
@@ -28246,7 +28443,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_STOP));
             }
-            await bt.strategyCoreService.stop(true, symbol, context);
+            await bt.strategyCoreService.stopStrategy(true, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
@@ -28271,24 +28468,65 @@ class BacktestUtils {
          * }, "manual-cancel-001");
          * ```
          */
-        this.commitCancel = async (symbol, context, cancelId) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_CANCEL, {
+        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
                 cancelId,
             });
-            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
-            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL);
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL);
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
                 actions &&
-                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL));
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
             }
-            await bt.strategyCoreService.cancel(true, symbol, context, cancelId);
+            await bt.strategyCoreService.cancelScheduled(true, symbol, context, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         *
+         * @example
+         * ```typescript
+         * // Close pending signal with custom ID
+         * await Backtest.commitClose("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy",
+         *   frameName: "1m"
+         * }, "manual-close-001");
+         * ```
+         */
+        this.commitClosePending = async (symbol, context, closeId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CLOSE_PENDING, {
+                symbol,
+                context,
+                closeId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
+            }
+            await bt.strategyCoreService.closePending(true, symbol, context, closeId);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -28725,7 +28963,8 @@ const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
-const LIVE_METHOD_NAME_CANCEL = "LiveUtils.commitCancel";
+const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
+const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
@@ -28930,7 +29169,7 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(false, symbol, {
+                bt.strategyCoreService.stopStrategy(false, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: ""
@@ -29197,7 +29436,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
                 actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_STOP));
             }
-            await bt.strategyCoreService.stop(false, symbol, {
+            await bt.strategyCoreService.stopStrategy(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -29226,26 +29465,67 @@ class LiveUtils {
          * }, "manual-cancel-001");
          * ```
          */
-        this.commitCancel = async (symbol, context, cancelId) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
+        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
                 cancelId,
             });
-            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
-            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL);
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL));
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
             }
-            await bt.strategyCoreService.cancel(false, symbol, {
+            await bt.strategyCoreService.cancelScheduled(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
             }, cancelId);
         };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         *
+         * @example
+         * ```typescript
+         * // Close pending signal with custom ID
+         * await Live.commitClose("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * }, "manual-close-001");
+         * ```
+         */
+        this.commitClosePending = async (symbol, context, closeId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CLOSE_PENDING, {
+                symbol,
+                context,
+                closeId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CLOSE_PENDING);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CLOSE_PENDING);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CLOSE_PENDING));
+            }
+            await bt.strategyCoreService.closePending(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, closeId);
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -30162,7 +30442,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    bt.strategyCoreService.stop(true, symbol, {
+                    bt.strategyCoreService.stopStrategy(true, symbol, {
                         strategyName,
                         exchangeName: walkerSchema.exchangeName,
                         frameName: walkerSchema.frameName
@@ -30318,7 +30598,7 @@ class WalkerUtils {
             }
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
-                await bt.strategyCoreService.stop(true, symbol, {
+                await bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName,
                     exchangeName: walkerSchema.exchangeName,
                     frameName: walkerSchema.frameName
@@ -32739,7 +33019,8 @@ exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
 exports.commitBreakeven = commitBreakeven;
-exports.commitCancel = commitCancel;
+exports.commitCancelScheduled = commitCancelScheduled;
+exports.commitClosePending = commitClosePending;
 exports.commitPartialLoss = commitPartialLoss;
 exports.commitPartialProfit = commitPartialProfit;
 exports.commitSignalPromptHistory = commitSignalPromptHistory;
@@ -32827,5 +33108,5 @@ exports.set = set;
 exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
-exports.stop = stop;
+exports.stopStrategy = stopStrategy;
 exports.validate = validate;