backtest-kit 6.15.0 → 6.16.0

package/build/index.cjs

@@ -734,6 +734,11 @@ const schedulePingSubject = new functoolsKit.Subject();
  * Allows users to track active signal lifecycle and implement custom dynamic management logic.
  */
 const activePingSubject = new functoolsKit.Subject();
+/**
+ * Idle ping emitter for strategy idle state events.
+ * Emits every tick when there is no pending or scheduled signal being monitored.
+ */
+const idlePingSubject = new functoolsKit.Subject();
 /**
  * Strategy management signal emitter.
  * Emits when strategy management actions are executed:
@@ -785,6 +790,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
     highestProfitSubject: highestProfitSubject,
+    idlePingSubject: idlePingSubject,
     maxDrawdownSubject: maxDrawdownSubject,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
@@ -6048,6 +6054,27 @@ const CALL_ACTIVE_PING_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (sel
         errorEmitter.next(error);
     },
 });
+const CALL_IDLE_PING_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (self, symbol, timestamp, backtest, currentPrice) => {
+    await ExecutionContextService.runInContext(async () => {
+        // Call system onIdlePing callback (emits to idlePingSubject)
+        await self.params.onIdlePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, currentPrice, self.params.execution.context.backtest, timestamp);
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}), {
+    fallback: (error, self) => {
+        const message = "ClientStrategy CALL_IDLE_PING_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 const CALL_ACTIVE_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onActive) {
@@ -6703,6 +6730,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice, backt
 };
 const RETURN_IDLE_FN = async (self, currentPrice) => {
     const currentTime = self.params.execution.context.when.getTime();
+    await CALL_IDLE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest, currentPrice);
     await CALL_IDLE_CALLBACKS_FN(self, self.params.execution.context.symbol, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "idle",
@@ -10375,11 +10403,44 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => functoolsKit.trycatch(async (sy
     },
     defaultValue: null,
 });
+/**
+ * Creates a callback function for emitting idle ping events.
+ *
+ * Called by ClientStrategy when no active or scheduled signals are present.
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Callback function for idle ping events
+ */
+const CREATE_COMMIT_IDLE_PING_FN = (self) => functoolsKit.trycatch(async (symbol, strategyName, exchangeName, currentPrice, backtest, timestamp) => {
+    const frameName = self.methodContextService.context.frameName;
+    const event = {
+        symbol,
+        strategyName,
+        exchangeName,
+        frameName,
+        currentPrice,
+        backtest,
+        timestamp,
+    };
+    await idlePingSubject.next(event);
+    await self.actionCoreService.pingIdle(backtest, event, { strategyName, exchangeName, frameName });
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_COMMIT_IDLE_PING_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting active ping events.
  *
  * Called by ClientStrategy when an active pending signal is being monitored every minute.
- * Placeholder for future activePingSubject implementation.
  *
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for active ping events
@@ -10626,6 +10687,7 @@ class StrategyConnectionService {
                 onInit: CREATE_COMMIT_INIT_FN(this),
                 onSchedulePing: CREATE_COMMIT_SCHEDULE_PING_FN(this),
                 onActivePing: CREATE_COMMIT_ACTIVE_PING_FN(this),
+                onIdlePing: CREATE_COMMIT_IDLE_PING_FN(this),
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
                 onCommit: CREATE_COMMIT_FN(this),
                 onSignalSync: CREATE_SYNC_FN(this, strategyName, exchangeName, frameName, backtest),
@@ -13104,6 +13166,34 @@ const CALL_PING_SCHEDULED_FN = functoolsKit.trycatch(async (event, self) => {
     },
     defaultValue: null,
 });
+/**
+ * Wrapper to call pingIdle method with error capture.
+ */
+const CALL_PING_IDLE_FN = functoolsKit.trycatch(async (event, self) => {
+    if (!self._target.pingIdle) {
+        return;
+    }
+    if (await self.params.strategy.hasPendingSignal(event.backtest, event.symbol, {
+        strategyName: event.strategyName,
+        exchangeName: event.exchangeName,
+        frameName: event.frameName,
+    })) {
+        return;
+    }
+    return await self._target.pingIdle(event);
+}, {
+    fallback: (error) => {
+        const message = "ActionProxy.pingIdle thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        LOGGER_SERVICE$4.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Wrapper to call pingActive method with error capture.
  */
@@ -13342,6 +13432,18 @@ class ActionProxy {
     async pingActive(event) {
         return await CALL_PING_ACTIVE_FN(event, this);
     }
+    /**
+     * Handles idle ping events with error capture.
+     *
+     * Wraps the user's pingIdle() method to catch and log any errors.
+     * Called every tick while no signal is pending or scheduled.
+     *
+     * @param event - Idle ping data with symbol, strategy info, current price, timestamp
+     * @returns Promise resolving to user's pingIdle() result or null on error
+     */
+    async pingIdle(event) {
+        return await CALL_PING_IDLE_FN(event, this);
+    }
     /**
      * Handles risk rejection events with error capture.
      *
@@ -13529,6 +13631,23 @@ const CALL_PING_SCHEDULED_CALLBACK_FN = functoolsKit.trycatch(async (self, event
         errorEmitter.next(error);
     },
 });
+/** Wrapper to call idle ping callback with error handling */
+const CALL_PING_IDLE_CALLBACK_FN = functoolsKit.trycatch(async (self, event, strategyName, frameName, backtest) => {
+    if (self.params.callbacks?.onPingIdle) {
+        await self.params.callbacks.onPingIdle(event, self.params.actionName, strategyName, frameName, backtest);
+    }
+}, {
+    fallback: (error, self) => {
+        const message = "ClientAction CALL_PING_IDLE_CALLBACK_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /** Wrapper to call active ping callback with error handling */
 const CALL_PING_ACTIVE_CALLBACK_FN = functoolsKit.trycatch(async (self, event, strategyName, frameName, backtest) => {
     if (self.params.callbacks?.onPingActive) {
@@ -13895,6 +14014,24 @@ class ClientAction {
         await CALL_PING_ACTIVE_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
     ;
+    /**
+     * Handles idle ping events when no signal is active.
+     */
+    async pingIdle(event) {
+        this.params.logger.debug("ClientAction pingIdle", {
+            actionName: this.params.actionName,
+            strategyName: this.params.strategyName,
+            frameName: this.params.frameName,
+        });
+        if (!this._handlerInstance) {
+            await this.waitForInit();
+        }
+        // Call handler method if defined
+        await this._handlerInstance?.pingIdle(event);
+        // Call callback if defined
+        await CALL_PING_IDLE_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+    }
+    ;
     /**
      * Handles risk rejection events when signals fail risk validation.
      */
@@ -14147,6 +14284,21 @@ class ActionConnectionService {
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
             await action.pingActive(event);
         };
+        /**
+         * Routes idle ping event to appropriate ClientAction instance.
+         *
+         * @param event - Idle ping event data
+         * @param backtest - Whether running in backtest mode
+         * @param context - Execution context with action name, strategy name, exchange name, frame name
+         */
+        this.pingIdle = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService pingIdle", {
+                backtest,
+                context,
+            });
+            const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await action.pingIdle(event);
+        };
         /**
          * Routes riskRejection event to appropriate ClientAction instance.
          *
@@ -16250,6 +16402,27 @@ class ActionCoreService {
                 await this.actionConnectionService.pingActive(event, backtest, { actionName, ...context });
             }
         };
+        /**
+         * Routes idle ping event to all registered actions for the strategy.
+         *
+         * Retrieves action list from strategy schema (IStrategySchema.actions)
+         * and invokes the pingIdle handler on each ClientAction instance sequentially.
+         * Called every tick when there is no pending or scheduled signal being monitored.
+         *
+         * @param backtest - Whether running in backtest mode (true) or live mode (false)
+         * @param event - Idle state monitoring data
+         * @param context - Strategy execution context with strategyName, exchangeName, frameName
+         */
+        this.pingIdle = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService pingIdle", {
+                context,
+            });
+            await this.validate(context);
+            const { actions = [] } = this.strategySchemaService.get(context.strategyName);
+            for (const actionName of actions) {
+                await this.actionConnectionService.pingIdle(event, backtest, { actionName, ...context });
+            }
+        };
         /**
          * Routes risk rejection event to all registered actions for the strategy.
          *
@@ -37820,6 +37993,8 @@ const LISTEN_SCHEDULE_PING_METHOD_NAME = "event.listenSchedulePing";
 const LISTEN_SCHEDULE_PING_ONCE_METHOD_NAME = "event.listenSchedulePingOnce";
 const LISTEN_ACTIVE_PING_METHOD_NAME = "event.listenActivePing";
 const LISTEN_ACTIVE_PING_ONCE_METHOD_NAME = "event.listenActivePingOnce";
+const LISTEN_IDLE_PING_METHOD_NAME = "event.listenIdlePing";
+const LISTEN_IDLE_PING_ONCE_METHOD_NAME = "event.listenIdlePingOnce";
 const LISTEN_STRATEGY_COMMIT_METHOD_NAME = "event.listenStrategyCommit";
 const LISTEN_STRATEGY_COMMIT_ONCE_METHOD_NAME = "event.listenStrategyCommitOnce";
 const LISTEN_SYNC_METHOD_NAME = "event.listenSync";
@@ -38995,6 +39170,45 @@ function listenActivePingOnce(filterFn, fn) {
     };
     return disposeFn = listenActivePing(wrappedFn);
 }
+/**
+ * Subscribes to idle ping events with queued async processing.
+ *
+ * Emits every tick when there is no pending or scheduled signal being monitored.
+ *
+ * @param fn - Callback function to handle idle ping events
+ * @returns Unsubscribe function to stop listening
+ */
+function listenIdlePing(fn) {
+    backtest.loggerService.log(LISTEN_IDLE_PING_METHOD_NAME);
+    const wrappedFn = async (event) => {
+        if (await functoolsKit.not(backtest.strategyCoreService.hasPendingSignal(event.backtest, event.symbol, {
+            strategyName: event.strategyName,
+            exchangeName: event.exchangeName,
+            frameName: event.frameName,
+        }))) {
+            await fn(event);
+        }
+    };
+    return idlePingSubject.subscribe(functoolsKit.queued(wrappedFn));
+}
+/**
+ * Subscribes to filtered idle ping events with one-time execution.
+ *
+ * @param filterFn - Predicate to filter events
+ * @param fn - Callback function to handle the matching event
+ * @returns Unsubscribe function to cancel the listener before it fires
+ */
+function listenIdlePingOnce(filterFn, fn) {
+    backtest.loggerService.log(LISTEN_IDLE_PING_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenIdlePing(wrappedFn);
+}
 /**
  * Subscribes to strategy management events with queued async processing.
  *
@@ -45952,6 +46166,7 @@ const RECENT_LIVE_ADAPTER_METHOD_NAME_CLEAR = "RecentLiveAdapter.clear";
 const RECENT_ADAPTER_METHOD_NAME_ENABLE = "RecentAdapter.enable";
 const RECENT_ADAPTER_METHOD_NAME_DISABLE = "RecentAdapter.disable";
 const RECENT_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL = "RecentAdapter.getLatestSignal";
+const RECENT_ADAPTER_METHOD_NAME_GET_MINUTES_SINCE_LATEST_SIGNAL = "RecentAdapter.getMinutesSinceLatestSignalCreated";
 /**
  * Builds a composite storage key from context parts.
  * Includes backtest flag as the last segment to prevent live/backtest collisions.
@@ -46010,6 +46225,23 @@ class RecentPersistBacktestUtils {
             });
             return await PersistRecentAdapter.readRecentData(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -46052,6 +46284,23 @@ class RecentMemoryBacktestUtils {
             backtest.loggerService.info(RECENT_MEMORY_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL, { key });
             return this._signals.get(key) ?? null;
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -46095,6 +46344,23 @@ class RecentPersistLiveUtils {
             });
             return await PersistRecentAdapter.readRecentData(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -46137,6 +46403,23 @@ class RecentMemoryLiveUtils {
             backtest.loggerService.info(RECENT_MEMORY_LIVE_METHOD_NAME_GET_LATEST_SIGNAL, { key });
             return this._signals.get(key) ?? null;
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -46183,6 +46466,32 @@ class RecentBacktestAdapter {
             });
             return await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * Proxies call to the underlying storage adapter.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+                timestamp,
+            });
+            const signal = await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
         /**
          * Sets the storage adapter constructor.
          * All future storage operations will use this adapter.
@@ -46261,6 +46570,32 @@ class RecentLiveAdapter {
             });
             return await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * Proxies call to the underlying storage adapter.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+                timestamp,
+            });
+            const signal = await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
         /**
          * Sets the storage adapter constructor.
          * All future storage operations will use this adapter.
@@ -46369,6 +46704,27 @@ class RecentAdapter {
             }
             return null;
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * Searches backtest storage first, then live storage.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         * @throws Error if RecentAdapter is not enabled
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, context) => {
+            backtest.loggerService.info(RECENT_ADAPTER_METHOD_NAME_GET_MINUTES_SINCE_LATEST_SIGNAL, {
+                symbol,
+                context,
+                timestamp,
+            });
+            const signal = await this.getLatestSignal(symbol, context);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -46388,6 +46744,7 @@ const RecentLive = new RecentLiveAdapter();
 const RecentBacktest = new RecentBacktestAdapter();
 
 const GET_LATEST_SIGNAL_METHOD_NAME = "signal.getLatestSignal";
+const GET_MINUTES_SINCE_LATEST_SIGNAL_CREATED_METHOD_NAME = "signal.getMinutesSinceLatestSignalCreated";
 /**
  * Returns the latest signal (pending or closed) for the current strategy context.
  *
@@ -46425,6 +46782,42 @@ async function getLatestSignal(symbol) {
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
     return await Recent.getLatestSignal(symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+ *
+ * Does not distinguish between active and closed signals — measures time since
+ * whichever signal was recorded last. Useful for cooldown logic after a stop-loss.
+ *
+ * Searches backtest storage first, then live storage.
+ * Returns null if no signal exists at all.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param timestamp - Current timestamp in milliseconds
+ * @returns Promise resolving to whole minutes since the latest signal was created, or null
+ *
+ * @example
+ * ```typescript
+ * import { getMinutesSinceLatestSignalCreated } from "backtest-kit";
+ *
+ * const minutes = await getMinutesSinceLatestSignalCreated("BTCUSDT", Date.now());
+ * if (minutes !== null && minutes < 24 * 60) {
+ *   return; // cooldown — skip new signal for 24 hours after last signal
+ * }
+ * ```
+ */
+async function getMinutesSinceLatestSignalCreated(symbol, timestamp) {
+    backtest.loggerService.info(GET_MINUTES_SINCE_LATEST_SIGNAL_CREATED_METHOD_NAME, { symbol, timestamp });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMinutesSinceLatestSignalCreated requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getMinutesSinceLatestSignalCreated requires a method context");
+    }
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await Recent.getMinutesSinceLatestSignalCreated(timestamp, symbol, { exchangeName, frameName, strategyName });
+}
 
 const DEFAULT_BM25_K1 = 1.5;
 const DEFAULT_BM25_B = 0.75;
@@ -49752,6 +50145,7 @@ const METHOD_NAME_CREATE_SNAPSHOT = "SessionUtils.createSnapshot";
 /** List of all global subjects whose listeners should be snapshotted for session isolation */
 const SUBJECT_ISOLATION_LIST = [
     activePingSubject,
+    idlePingSubject,
     backtestScheduleOpenSubject,
     breakevenSubject,
     doneBacktestSubject,
@@ -57872,6 +58266,7 @@ const METHOD_NAME_PARTIAL_PROFIT_AVAILABLE = "ActionBase.partialProfitAvailable"
 const METHOD_NAME_PARTIAL_LOSS_AVAILABLE = "ActionBase.partialLossAvailable";
 const METHOD_NAME_PING_SCHEDULED = "ActionBase.pingScheduled";
 const METHOD_NAME_PING_ACTIVE = "ActionBase.pingActive";
+const METHOD_NAME_PING_IDLE = "ActionBase.pingIdle";
 const METHOD_NAME_RISK_REJECTION = "ActionBase.riskRejection";
 const METHOD_NAME_DISPOSE = "ActionBase.dispose";
 const DEFAULT_SOURCE = "default";
@@ -58265,6 +58660,26 @@ class ActionBase {
             source,
         });
     }
+    /**
+     * Handles idle ping events when no signal is active.
+     *
+     * Called every tick while no signal is pending or scheduled.
+     * Use to monitor idle strategy state and implement entry condition logic.
+     *
+     * Triggered by: ActionCoreService.pingIdle() via StrategyConnectionService
+     * Source: idlePingSubject.next() in CREATE_COMMIT_IDLE_PING_FN callback
+     * Frequency: Every tick while no signal is pending or scheduled
+     *
+     * Default implementation: Logs idle ping event.
+     *
+     * @param event - Idle ping data with symbol, strategy info, current price, timestamp
+     */
+    pingIdle(event, source = DEFAULT_SOURCE) {
+        LOGGER_SERVICE.info(METHOD_NAME_PING_IDLE, {
+            event,
+            source,
+        });
+    }
     /**
      * Handles risk rejection events when signals fail risk validation.
      *
@@ -58708,6 +59123,7 @@ exports.getFrameSchema = getFrameSchema;
 exports.getLatestSignal = getLatestSignal;
 exports.getMaxDrawdownDistancePnlCost = getMaxDrawdownDistancePnlCost;
 exports.getMaxDrawdownDistancePnlPercentage = getMaxDrawdownDistancePnlPercentage;
+exports.getMinutesSinceLatestSignalCreated = getMinutesSinceLatestSignalCreated;
 exports.getMode = getMode;
 exports.getNextCandles = getNextCandles;
 exports.getOrderBook = getOrderBook;
@@ -58780,6 +59196,8 @@ exports.listenError = listenError;
 exports.listenExit = listenExit;
 exports.listenHighestProfit = listenHighestProfit;
 exports.listenHighestProfitOnce = listenHighestProfitOnce;
+exports.listenIdlePing = listenIdlePing;
+exports.listenIdlePingOnce = listenIdlePingOnce;
 exports.listenMaxDrawdown = listenMaxDrawdown;
 exports.listenMaxDrawdownOnce = listenMaxDrawdownOnce;
 exports.listenPartialLossAvailable = listenPartialLossAvailable;