backtest-kit 11.7.0 → 11.9.0

package/build/index.cjs

@@ -94,6 +94,7 @@ const metaServices$1 = {
     contextMetaService: Symbol('contextMetaService'),
     priceMetaService: Symbol('priceMetaService'),
     timeMetaService: Symbol('timeMetaService'),
+    runtimeMetaService: Symbol('runtimeMetaService'),
 };
 const globalServices$1 = {
     sizingGlobalService: Symbol('sizingGlobalService'),
@@ -4680,7 +4681,7 @@ const LOGGER_SERVICE$8 = new LoggerService();
  * @param backtest - `true` for backtest, `false` for live.
  * @returns Colon-joined composite key.
  */
-const CREATE_KEY_FN$y = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$B = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -4723,7 +4724,7 @@ class LookupUtils {
             LOGGER_SERVICE$8.info(METHOD_NAME_ADD_ACTIVITY, {
                 activity,
             });
-            const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
+            const key = CREATE_KEY_FN$B(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
             this._lookupMap.set(key, activity);
         };
         /**
@@ -4737,7 +4738,7 @@ class LookupUtils {
             LOGGER_SERVICE$8.info(METHOD_NAME_REMOVE_ACTIVITY, {
                 activity,
             });
-            const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
+            const key = CREATE_KEY_FN$B(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
             this._lookupMap.delete(key);
         };
         /**
@@ -12355,7 +12356,7 @@ const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$x = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$A = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12376,6 +12377,7 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => functoolsKit.trycatch(async (sy
         symbol,
         strategyName,
         exchangeName,
+        frameName: data.frameName,
         currentPrice,
         data,
         backtest,
@@ -12443,6 +12445,7 @@ const CREATE_COMMIT_ACTIVE_PING_FN = (self) => functoolsKit.trycatch(async (symb
         symbol,
         strategyName,
         exchangeName,
+        frameName: data.frameName,
         currentPrice,
         data,
         backtest,
@@ -12655,7 +12658,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$x(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        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);
             return new ClientStrategy({
                 symbol,
@@ -13617,7 +13620,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$x(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$A(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -14015,11 +14018,51 @@ class StrategyConnectionService {
     }
 }
 
+const MS_PER_MINUTE$6 = 60000;
+const INTERVAL_MINUTES$7 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+    "1d": 1440,
+};
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param date - Date to align
+ * @param interval - Candle interval (e.g., "1m", "15m", "1h")
+ * @returns New Date aligned down to interval boundary
+ */
+const alignToInterval = (date, interval) => {
+    const minutes = INTERVAL_MINUTES$7[interval];
+    if (minutes === undefined) {
+        throw new Error(`alignToInterval: unknown interval=${interval}`);
+    }
+    const intervalMs = minutes * MS_PER_MINUTE$6;
+    return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
+};
+
 /**
  * Maps FrameInterval to minutes for timestamp calculation.
  * Used to generate timeframe arrays with proper spacing.
  */
-const INTERVAL_MINUTES$7 = {
+const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -14073,7 +14116,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         symbol,
     });
     const { interval, startDate, endDate } = self.params;
-    const intervalMinutes = INTERVAL_MINUTES$7[interval];
+    const intervalMinutes = INTERVAL_MINUTES$6[interval];
     if (!intervalMinutes) {
         throw new Error(`ClientFrame unknown interval: ${interval}`);
     }
@@ -14082,8 +14125,14 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
     today.setUTCHours(0, 0, 0, 0);
     // Ensure endDate doesn't go beyond today
     const effectiveEndDate = endDate > today ? today : endDate;
+    // Align the iteration start down to the 1-minute boundary so every generated
+    // timestamp lands on a clean minute, matching live mode
+    // (LiveLogicPrivateService aligns `when` via alignToInterval(new Date(), "1m")).
+    // Without this, a startDate carrying sub-minute (or any non-aligned) offset
+    // would propagate that offset to every tick `when` — and therefore to
+    // IRuntimeInfo.when handed to Cron handlers — diverging from live behaviour.
     const timeframes = [];
-    let currentDate = new Date(startDate);
+    let currentDate = alignToInterval(startDate, "1m");
     while (currentDate <= effectiveEndDate) {
         timeframes.push(new Date(currentDate));
         currentDate = new Date(currentDate.getTime() + intervalMinutes * 60 * 1000);
@@ -14117,6 +14166,7 @@ class ClientFrame {
     }
 }
 
+const DEFAULT_INTERVAL = "1m";
 /**
  * Connection service routing frame operations to correct ClientFrame instance.
  *
@@ -14160,7 +14210,7 @@ class FrameConnectionService {
                 logger: this.loggerService,
                 startDate,
                 endDate,
-                interval,
+                interval: interval || DEFAULT_INTERVAL,
                 callbacks,
             });
         });
@@ -14819,7 +14869,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$w = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$z = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -14919,7 +14969,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$w(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = functoolsKit.memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$z(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -15009,7 +15059,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$w(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$z(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -16128,7 +16178,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$v = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$y = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -16180,7 +16230,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = functoolsKit.memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$v(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = functoolsKit.memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$y(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -16406,7 +16456,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$v(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$y(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -16417,14 +16467,14 @@ class ActionConnectionService {
     }
 }
 
-const METHOD_NAME_VALIDATE$3 = "exchangeCoreService validate";
+const METHOD_NAME_VALIDATE$6 = "exchangeCoreService validate";
 /**
  * Creates a unique key for memoizing validate calls.
  * Key format: "exchangeName"
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$u = (exchangeName) => {
+const CREATE_KEY_FN$x = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -16448,11 +16498,11 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$u(exchangeName), async (exchangeName) => {
-            this.loggerService.log(METHOD_NAME_VALIDATE$3, {
+        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$x(exchangeName), async (exchangeName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$6, {
                 exchangeName,
             });
-            this.exchangeValidationService.validate(exchangeName, METHOD_NAME_VALIDATE$3);
+            this.exchangeValidationService.validate(exchangeName, METHOD_NAME_VALIDATE$6);
         });
         /**
          * Fetches historical candles with execution context.
@@ -16721,14 +16771,14 @@ class ExchangeCoreService {
     }
 }
 
-const METHOD_NAME_VALIDATE$2 = "strategyCoreService validate";
+const METHOD_NAME_VALIDATE$5 = "strategyCoreService validate";
 /**
  * Creates a unique key for memoizing validate calls.
  * Key format: "strategyName:exchangeName:frameName"
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$t = (context) => {
+const CREATE_KEY_FN$w = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -16751,6 +16801,7 @@ class StrategyCoreService {
         this.strategyValidationService = inject(TYPES.strategyValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         this.frameValidationService = inject(TYPES.frameValidationService);
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * Validates strategy and associated risk configuration.
          *
@@ -16760,16 +16811,17 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$t(context), async (context) => {
-            this.loggerService.log(METHOD_NAME_VALIDATE$2, {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$w(context), async (context) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$5, {
                 context,
             });
-            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$2);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$2);
-            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$2);
-            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$2);
-            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$2));
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$5);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$5);
+            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$5);
+            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$5);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$5));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_VALIDATE$5));
         });
         /**
          * Retrieves the currently active pending signal for the symbol.
@@ -18130,7 +18182,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$s = (context) => {
+const CREATE_KEY_FN$v = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -18156,7 +18208,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$s(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$v(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -18248,14 +18300,14 @@ class RiskGlobalService {
     }
 }
 
-const METHOD_NAME_VALIDATE$1 = "actionCoreService validate";
+const METHOD_NAME_VALIDATE$4 = "actionCoreService validate";
 /**
  * Creates a unique key for memoizing validate calls.
  * Key format: "strategyName:exchangeName:frameName"
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$r = (context) => {
+const CREATE_KEY_FN$u = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -18299,17 +18351,17 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$r(context), async (context) => {
-            this.loggerService.log(METHOD_NAME_VALIDATE$1, {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$u(context), async (context) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$4, {
                 context,
             });
             const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$1);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$1);
-            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$1);
-            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$1);
-            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$1));
-            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_VALIDATE$1));
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$4);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$4);
+            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$4);
+            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$4);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$4));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_VALIDATE$4));
         });
         /**
          * Initializes all ClientAction instances for the strategy.
@@ -18805,8 +18857,8 @@ class FrameSchemaService {
             if (typeof frameSchema.frameName !== "string") {
                 throw new Error(`frame schema validation failed: missing frameName`);
             }
-            if (typeof frameSchema.interval !== "string") {
-                throw new Error(`frame schema validation failed: missing interval for frameName=${frameSchema.frameName}`);
+            if (frameSchema.interval && typeof frameSchema.interval !== "string") {
+                throw new Error(`frame schema validation failed: invalid interval for frameName=${frameSchema.frameName}`);
             }
             if (!(frameSchema.startDate instanceof Date)) {
                 throw new Error(`frame schema validation failed: missing startDate for frameName=${frameSchema.frameName}`);
@@ -19934,8 +19986,8 @@ class BacktestLogicPrivateService {
 }
 
 const EMITTER_CHECK_INTERVAL = 5000;
-const MS_PER_MINUTE$6 = 60000;
-const INTERVAL_MINUTES$6 = {
+const MS_PER_MINUTE$5 = 60000;
+const INTERVAL_MINUTES$5 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -19950,7 +20002,7 @@ const INTERVAL_MINUTES$6 = {
 };
 const createEmitter = functoolsKit.memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new functoolsKit.Subject();
-    const intervalMs = INTERVAL_MINUTES$6[interval] * MS_PER_MINUTE$6;
+    const intervalMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$5;
     {
         let lastAligned = Math.floor(Date.now() / intervalMs) * intervalMs;
         functoolsKit.Source.fromInterval(EMITTER_CHECK_INTERVAL)
@@ -19977,46 +20029,6 @@ const waitForCandle = async (interval) => {
     return emitter.toPromise();
 };
 
-const MS_PER_MINUTE$5 = 60000;
-const INTERVAL_MINUTES$5 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-    "1d": 1440,
-};
-/**
- * Aligns timestamp down to the nearest interval boundary.
- * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
- *
- * Candle timestamp convention:
- * - Candle timestamp = openTime (when candle opens)
- * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
- *
- * Adapter contract:
- * - Adapter must return candles with timestamp = openTime
- * - First returned candle.timestamp must equal aligned since
- * - Adapter must return exactly `limit` candles
- *
- * @param date - Date to align
- * @param interval - Candle interval (e.g., "1m", "15m", "1h")
- * @returns New Date aligned down to interval boundary
- */
-const alignToInterval = (date, interval) => {
-    const minutes = INTERVAL_MINUTES$5[interval];
-    if (minutes === undefined) {
-        throw new Error(`alignToInterval: unknown interval=${interval}`);
-    }
-    const intervalMs = minutes * MS_PER_MINUTE$5;
-    return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
-};
-
 /**
  * Private service for live trading orchestration using async generators.
  *
@@ -20839,6 +20851,17 @@ class WalkerLogicPublicService {
 }
 
 const METHOD_NAME_RUN$2 = "liveCommandService run";
+const METHOD_NAME_VALIDATE$3 = "liveCommandService validate";
+/**
+ * Creates a unique key for memoizing validate calls.
+ * Key format: "strategyName:exchangeName:frameName"
+ * @param context - Context with strategyName, exchangeName, frameName
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$t = (context) => {
+    const parts = [context.strategyName, context.exchangeName];
+    return parts.join(":");
+};
 /**
  * Global service providing access to live trading functionality.
  *
@@ -20854,6 +20877,25 @@ class LiveCommandService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.actionValidationService = inject(TYPES.actionValidationService);
+        /**
+         * Validates strategy and associated risk configuration.
+         * Memoized to avoid redundant validations for the same strategy-exchange combination.
+         *
+         * @param context - Context with strategyName, exchangeName
+         * @param methodName - Name of the calling method for error tracking
+         */
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$t(context), (context, methodName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$3, {
+                context,
+                methodName,
+            });
+            this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
+            riskName && this.riskValidationService.validate(riskName, methodName);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
+        });
         /**
          * Runs live trading for a symbol with context propagation.
          *
@@ -20868,22 +20910,26 @@ class LiveCommandService {
                 symbol,
                 context,
             });
-            {
-                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$2);
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$2);
-            }
-            {
-                const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
-                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$2);
-                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$2));
-                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_RUN$2));
-            }
+            this.validate(context, METHOD_NAME_RUN$2);
             return this.liveLogicPublicService.run(symbol, context);
         };
     }
 }
 
 const METHOD_NAME_RUN$1 = "backtestCommandService run";
+const METHOD_NAME_VALIDATE$2 = "backtestCommandService validate";
+/**
+ * Creates a unique key for memoizing validate calls.
+ * Key format: "strategyName:exchangeName:frameName"
+ * @param context - Context with strategyName, exchangeName, frameName
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$s = (context) => {
+    const parts = [context.strategyName, context.exchangeName];
+    if (context.frameName)
+        parts.push(context.frameName);
+    return parts.join(":");
+};
 /**
  * Global service providing access to backtest functionality.
  *
@@ -20900,6 +20946,26 @@ class BacktestCommandService {
         this.strategyValidationService = inject(TYPES.strategyValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         this.frameValidationService = inject(TYPES.frameValidationService);
+        /**
+         * Validates strategy and associated risk configuration.
+         * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
+         *
+         * @param context - Context with strategyName, exchangeName and frameName
+         * @param methodName - Name of the calling method for error tracking
+         */
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$s(context), (context, methodName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$2, {
+                context,
+                methodName,
+            });
+            this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
+            this.frameValidationService.validate(context.frameName, methodName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
+            riskName && this.riskValidationService.validate(riskName, methodName);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
+        });
         /**
          * Runs backtest for a symbol with context propagation.
          *
@@ -20912,23 +20978,26 @@ class BacktestCommandService {
                 symbol,
                 context,
             });
-            {
-                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
-                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
-            }
-            {
-                const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
-                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1);
-                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1));
-                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_RUN$1));
-            }
+            this.validate(context, METHOD_NAME_RUN$1);
             return this.backtestLogicPublicService.run(symbol, context);
         };
     }
 }
 
 const METHOD_NAME_RUN = "walkerCommandService run";
+const METHOD_NAME_VALIDATE$1 = "walkerCommandService validate";
+/**
+ * Creates a unique key for memoizing validate calls.
+ * Key format: "walkerName:exchangeName:frameName"
+ * @param context - Context with walkerName, exchangeName, frameName
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$r = (context) => {
+    const parts = [context.walkerName, context.exchangeName];
+    if (context.frameName)
+        parts.push(context.frameName);
+    return parts.join(":");
+};
 /**
  * Global service providing access to walker functionality.
  *
@@ -20947,6 +21016,34 @@ class WalkerCommandService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.actionValidationService = inject(TYPES.actionValidationService);
+        /**
+         * Validates walker and associated strategy configurations.
+         * Memoized to avoid redundant validations for the same walker-exchange-frame combination.
+         *
+         * Strategy/risk/action validation is performed explicitly here in addition to the
+         * cascade inside WalkerValidationService — this is critical-path code and the
+         * redundant check is intentional defense-in-depth.
+         *
+         * @param context - Context with walkerName, exchangeName and frameName
+         * @param methodName - Name of the calling method for error tracking
+         */
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$r(context), (context, methodName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$1, {
+                context,
+                methodName,
+            });
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
+            this.frameValidationService.validate(context.frameName, methodName);
+            this.walkerValidationService.validate(context.walkerName, methodName);
+            const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                const { riskName, riskList, actions } = this.strategySchemaService.get(strategyName);
+                this.strategyValidationService.validate(strategyName, methodName);
+                riskName && this.riskValidationService.validate(riskName, methodName);
+                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
+            }
+        });
         /**
          * Runs walker comparison for a symbol with context propagation.
          *
@@ -20958,21 +21055,7 @@ class WalkerCommandService {
                 symbol,
                 context,
             });
-            {
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
-                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
-                this.walkerValidationService.validate(context.walkerName, METHOD_NAME_RUN);
-            }
-            {
-                const walkerSchema = this.walkerSchemaService.get(context.walkerName);
-                for (const strategyName of walkerSchema.strategies) {
-                    const { riskName, riskList, actions } = this.strategySchemaService.get(strategyName);
-                    this.strategyValidationService.validate(strategyName, METHOD_NAME_RUN);
-                    riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN);
-                    riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN));
-                    actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_RUN));
-                }
-            }
+            this.validate(context, METHOD_NAME_RUN);
             return this.walkerLogicPublicService.run(symbol, context);
         };
     }
@@ -28695,6 +28778,36 @@ class WalkerValidationService {
          * Injected logger service instance
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * @readonly
+         * Injected walker schema service instance
+         */
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+        /**
+         * @private
+         * @readonly
+         * Injected strategy validation service instance
+         */
+        this.strategyValidationService = inject(TYPES.strategyValidationService);
+        /**
+         * @private
+         * @readonly
+         * Injected strategy schema service instance
+         */
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        /**
+         * @private
+         * @readonly
+         * Injected risk validation service instance
+         */
+        this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * @private
+         * @readonly
+         * Injected action validation service instance
+         */
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * @private
          * Map storing walker schemas by walker name
@@ -28716,9 +28829,12 @@ class WalkerValidationService {
             this._walkerMap.set(walkerName, walkerSchema);
         };
         /**
-         * Validates the existence of a walker
+         * Validates the existence of a walker and its associated strategy configurations.
+         * Each strategy referenced by the walker is validated via StrategyValidationService,
+         * which in turn validates the strategy's risk profiles and actions.
          * @public
          * @throws {Error} If walkerName is not found
+         * @throws {Error} If any referenced strategy (or its risk/actions) is invalid
          * Memoized function to cache validation results
          */
         this.validate = functoolsKit.memoize(([walkerName]) => walkerName, (walkerName, source) => {
@@ -28730,6 +28846,14 @@ class WalkerValidationService {
             if (!walker) {
                 throw new Error(`walker ${walkerName} not found source=${source}`);
             }
+            const walkerSchema = this.walkerSchemaService.get(walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                const { riskName, riskList, actions } = this.strategySchemaService.get(strategyName);
+                this.strategyValidationService.validate(strategyName, source);
+                riskName && this.riskValidationService.validate(riskName, source);
+                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, source));
+                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, source));
+            }
             return true;
         });
         /**
@@ -30166,6 +30290,10 @@ class PartialGlobalService {
          * Frame validation service for validating frame existence.
          */
         this.frameValidationService = inject(TYPES.frameValidationService);
+        /**
+         * Action validation service for validating action existence.
+         */
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -30181,9 +30309,10 @@ class PartialGlobalService {
             this.strategyValidationService.validate(context.strategyName, methodName);
             this.exchangeValidationService.validate(context.exchangeName, methodName);
             context.frameName && this.frameValidationService.validate(context.frameName, methodName);
-            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
         });
         /**
          * Processes profit state and emits events for newly reached profit levels.
@@ -31250,6 +31379,10 @@ class BreakevenGlobalService {
          * Frame validation service for validating frame existence.
          */
         this.frameValidationService = inject(TYPES.frameValidationService);
+        /**
+         * Action validation service for validating frame existence.
+         */
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -31265,9 +31398,10 @@ class BreakevenGlobalService {
             this.strategyValidationService.validate(context.strategyName, methodName);
             this.exchangeValidationService.validate(context.exchangeName, methodName);
             context.frameName && this.frameValidationService.validate(context.frameName, methodName);
-            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
         });
         /**
          * Checks if breakeven should be triggered and emits event if conditions met.
@@ -36155,6 +36289,21 @@ class PriceMetaService {
          * Instances are cached until clear() is called.
          */
         this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        /**
+         * Checks if a price exists for the given key and has emitted at least one value.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns True if a price exists and has emitted a value, false otherwise
+         */
+        this.hasPrice = (symbol, context, backtest) => {
+            const key = CREATE_KEY_FN$b(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            if (!this.getSource.has(key)) {
+                return false;
+            }
+            return !!this.getSource.get(key)?.data;
+        };
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -36817,6 +36966,129 @@ class NotificationHelperService {
     }
 }
 
+const GET_RANGE_FN = functoolsKit.trycatch((self, context, backtest) => {
+    if (!backtest) {
+        return null;
+    }
+    const { startDate, endDate } = self.frameSchemaService.get(context.frameName);
+    return {
+        from: startDate,
+        to: endDate,
+    };
+}, {
+    fallback: (error, self) => {
+        const message = "RuntimeMetaService GET_RANGE_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+const GET_INFO_FN = functoolsKit.trycatch((self, context) => {
+    const { info } = self.strategySchemaService.get(context.strategyName);
+    return info || null;
+}, {
+    fallback: (error, self) => {
+        const message = "RuntimeMetaService GET_INFO_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+const GET_PRICE_FN = functoolsKit.trycatch(async (self, symbol, context, backtest) => {
+    return await self.priceMetaService.getCurrentPrice(symbol, context, backtest);
+}, {
+    fallback: (error, self) => {
+        const message = "RuntimeMetaService GET_PRICE_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+const RuntimeMetaService = diSingleton.singleton(class {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.timeMetaService = inject(TYPES.timeMetaService);
+        this.priceMetaService = inject(TYPES.priceMetaService);
+        this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        /**
+         * Fetches the time range for the current strategy execution context.
+         *
+         * For backtest mode, it retrieves the start and end dates from the frame schema.
+         * For live mode, it returns null since there is no predefined time range.
+         *
+         * This method is memoized to optimize performance, as the time range for a given context will not change during execution.
+         *
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns An object containing 'from' and 'to' Date objects for backtest mode, or null for live mode
+         */
+        this._getRange = functoolsKit.memoize(([context, backtest]) => `${context.frameName}:${backtest ? "backtest" : "live"}`, (context, backtest) => {
+            return GET_RANGE_FN(this, context, backtest);
+        });
+        /**
+         * Fetches strategy-defined runtime information for the current execution context.
+         *
+         * This method retrieves the 'info' object defined in the strategy schema, which can contain any custom data the strategy wants to track at runtime.
+         * The content of this object is not defined by the system and can be used freely by strategy implementations for monitoring, reporting, or external logic.
+         *
+         * This method is memoized to optimize performance, as the strategy info for a given context will not change during execution.
+         *
+         * @param context - Strategy, exchange, and frame identifiers
+         * @returns The 'info' object defined in the strategy schema for the given strategy, or null if not defined
+         */
+        this._getInfo = functoolsKit.memoize(([context]) => context.strategyName, (context) => {
+            return GET_INFO_FN(this, context);
+        });
+        /**
+         * Fetches comprehensive runtime information for a given symbol and strategy context, including current price, timestamp, and strategy-specific info.
+         *
+         * This method aggregates data from multiple sources (time, price, frame schema, strategy schema) to provide a complete picture of the current runtime state for a strategy tick.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns An object containing symbol, time range, strategy-defined info, context, timestamp, current price, and backtest flag
+         */
+        this.getRuntimeInfo = async (symbol, context, backtest) => {
+            this.loggerService.log("runtimeMetaService getRuntimeInfo", {
+                symbol,
+                context,
+                backtest,
+            });
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            const when = new Date(timestamp);
+            const currentPrice = await GET_PRICE_FN(this, symbol, context, backtest);
+            const range = this._getRange(context, backtest);
+            const info = this._getInfo(context);
+            return {
+                symbol,
+                range,
+                info,
+                context,
+                backtest,
+                when,
+                currentPrice,
+            };
+        };
+    }
+});
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -36853,6 +37125,7 @@ class NotificationHelperService {
     provide(TYPES.contextMetaService, () => new ContextMetaService());
     provide(TYPES.priceMetaService, () => new PriceMetaService());
     provide(TYPES.timeMetaService, () => new TimeMetaService());
+    provide(TYPES.runtimeMetaService, () => new RuntimeMetaService());
 }
 {
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
@@ -36956,6 +37229,7 @@ const metaServices = {
     timeMetaService: inject(TYPES.timeMetaService),
     priceMetaService: inject(TYPES.priceMetaService),
     contextMetaService: inject(TYPES.contextMetaService),
+    runtimeMetaService: inject(TYPES.runtimeMetaService),
 };
 const globalServices = {
     sizingGlobalService: inject(TYPES.sizingGlobalService),
@@ -50469,6 +50743,7 @@ const GET_TIMESTAMP_METHOD_NAME = "meta.getTimestamp";
 const GET_MODE_METHOD_NAME = "meta.getMode";
 const GET_SYMBOL_METHOD_NAME = "meta.getSymbol";
 const GET_CONTEXT_METHOD_NAME = "meta.getContext";
+const GET_RUNTIME_INFO_METHOD_NAME = "meta.getRuntimeInfo";
 /**
  * Gets the current date from execution context.
  *
@@ -50585,6 +50860,45 @@ async function getContext() {
     }
     return backtest.methodContextService.context;
 }
+/**
+ * Gets runtime information about the current execution environment.
+ *
+ * This includes details such as the current symbol, exchange, timeframe, strategy, and whether it's a backtest or live run.
+ *
+ * @returns Promise resolving to an object containing runtime information
+ * @throws Error if method context or execution context is not active
+ *
+ * @example
+ * ```typescript
+ * const runtimeInfo = await getRuntimeInfo();
+ * console.log(runtimeInfo);
+ * // {
+ * //   symbol: "BTCUSDT",
+ * //   context: {,
+ * //     exchangeName: "Binance",
+ * //     frameName: "1m",
+ * //     strategyName: "MyStrategy",
+ * //   },
+ * //   backtest: false
+ * // }
+ * ```
+ */
+async function getRuntimeInfo() {
+    backtest.loggerService.info(GET_RUNTIME_INFO_METHOD_NAME);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getRuntimeInfo requires a method context");
+    }
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getRuntimeInfo requires an execution context");
+    }
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    const { symbol, backtest: isBacktest } = backtest.executionContextService.context;
+    return await backtest.runtimeMetaService.getRuntimeInfo(symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    }, isBacktest);
+}
 
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistBacktestUtils.handleActivePing";
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL = "RecentPersistBacktestUtils.getLatestSignal";
@@ -64611,6 +64925,20 @@ const CRON_METHOD_NAME_TICK = "CronUtils._tick";
 const CRON_METHOD_NAME_ENABLE = "CronUtils.enable";
 const CRON_METHOD_NAME_DISABLE = "CronUtils.disable";
 const CRON_METHOD_NAME_DISPOSE = "CronUtils.dispose";
+/**
+ * Watchdog timeout (ms) for a single cron handler invocation.
+ *
+ * A handler that does not settle within this window is treated as failed:
+ * `_runEntry` races `entry.handler(info)` against this `sleep` and, when the
+ * timeout wins, throws into the same `catch` as any other handler error —
+ * surfacing `failed = true`, logging a warning, and (for periodic entries)
+ * rolling back the watermark so the boundary is retried on the next tick.
+ *
+ * This guards the `singlerun`-serialised tick pipeline against a handler that
+ * never resolves (a lost `resolve`, a hung promise with no timeout of its
+ * own): without it such a handler would stall every subsequent tick forever.
+ */
+const CRON_HANDLER_TIMEOUT = 120000;
 /**
  * Local logger instance.
  *
@@ -64619,6 +64947,20 @@ const CRON_METHOD_NAME_DISPOSE = "CronUtils.dispose";
  * being bootstrapped — `Cron` can be imported and used in isolation.
  */
 const LOGGER_SERVICE$1 = new LoggerService();
+/**
+ * Local runtime-meta-service instance.
+ *
+ * Like {@link LOGGER_SERVICE}, instantiated directly via `new` rather than
+ * resolved from the DI container so `CronUtils` carries no compile-time
+ * dependency on a bootstrapped framework. `RuntimeMetaService` is built with
+ * the `singleton` HOF from `di-singleton`, so `new RuntimeMetaService()`
+ * returns the one shared singleton proxy — the same instance the rest of the
+ * framework injects — and resolves its own dependencies lazily on first use.
+ *
+ * Used by {@link CronUtils._runEntry} to assemble the {@link IRuntimeInfo}
+ * snapshot handed to each cron handler.
+ */
+const RUNTIME_META_SERVICE = new RuntimeMetaService();
 /**
  * Utility class for registering periodic tasks that fire on candle-interval
  * boundaries of the virtual time produced by parallel backtests.
@@ -64641,8 +64983,8 @@ const LOGGER_SERVICE$1 = new LoggerService();
  * Cron.register({
  *   name: "tg-signal-parser",
  *   interval: "1h",
- *   handler: async (symbol, when, backtest) => {
- *     await parseTelegramSignalsToMongo(when);
+ *   handler: async (info) => {
+ *     await parseTelegramSignalsToMongo(info.when);
  *   },
  * });
  *
@@ -64684,12 +65026,15 @@ class CronUtils {
          * - Fire-once global: `${name}:once:g${generation}`.
          * - Fire-once fan-out: `${name}:once:${symbol}:g${generation}`.
          *
-         * Value is the shared in-flight handler promise. Every parallel `tick` for
-         * the same slot key awaits this exact promise (mutex semantics) and is
-         * released together when it settles. `_inFlight` is owned exclusively by
-         * `_runEntry` — `clear()` does **not** touch it, so the singleshot promise
-         * survives concurrent `clear` calls and continues to coordinate parallel
-         * ticks until it settles.
+         * Value is the shared in-flight handler promise. It resolves to a `boolean`
+         * "failed" flag (`true` when the handler — or the runtime-info assembly —
+         * threw), which `_tick` uses to roll back the periodic watermark of the slot
+         * it opened so a failed boundary is retried. Every parallel `tick` for the
+         * same slot key awaits this exact promise (mutex semantics) and is released
+         * together when it settles. `_inFlight` is owned exclusively by `_runEntry` —
+         * `clear()` does **not** touch it, so the singleshot promise survives
+         * concurrent `clear` calls and continues to coordinate parallel ticks until
+         * it settles.
          */
         this._inFlight = new Map();
         /**
@@ -64733,9 +65078,12 @@ class CronUtils {
          *
          * Written synchronously in `_tick` at slot-open time (before the `await`),
          * so a still-in-flight handler does not let a later tick re-open the same
-         * (or an already-passed) boundary. Fire-once entries never touch this map —
-         * they use `_firedOnce`. Pruned by `_clearBoundaryFor` on
-         * `register`/`unregister` and wiped by `dispose`.
+         * (or an already-passed) boundary. If that handler then **fails**, the
+         * advance is rolled back after the slot settles — the prior value is restored
+         * (or the key deleted if there was none) — so the failed boundary is retried
+         * on the next tick, mirroring catch-up of a skipped boundary. Fire-once
+         * entries never touch this map — they use `_firedOnce`. Pruned by
+         * `_clearBoundaryFor` on `register`/`unregister` and wiped by `dispose`.
          */
         this._lastBoundary = new Map();
         /**
@@ -64755,7 +65103,7 @@ class CronUtils {
          *   name: "fetch-funding",
          *   interval: "8h",
          *   symbols: ["BTCUSDT", "ETHUSDT"],
-         *   handler: async (symbol, when, backtest) => { ... },
+         *   handler: async (info) => { ... },
          * });
          * // Later:
          * dispose();
@@ -64875,7 +65223,7 @@ class CronUtils {
          * 4. **Fire-once** (`entry.interval === undefined`):
          *    - If the entry's fired-once key is already in `_firedOnce`, skip.
          *    - Slot key: `${name}:once` (+ scope) (+ gen).
-         *    - `aligned` = the 1-minute-aligned `when` from step 0.
+         *    - `alignedMs` = the 1-minute-aligned `when` from step 0 (`ts`).
          * 5. **Periodic** (`entry.interval` set):
          *    - Align `when` to the entry's interval via {@link alignToInterval} to
          *      get `alignedMs`, the boundary this tick belongs to.
@@ -64897,32 +65245,44 @@ class CronUtils {
          *      handler is still in flight.
          *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
          * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
-         *    already exists, `await` the same promise. Otherwise invoke
-         *    `entry.handler`, store the promise, and `await` it. The slot is
-         *    removed in `.finally()` so the next boundary creates a fresh promise;
-         *    for fire-once entries the fired-once key is also added to
-         *    `_firedOnce` on success so subsequent ticks skip it.
+         *    already exists, `await` the same promise. Otherwise open the slot via
+         *    {@link _runEntry} — which assembles the {@link IRuntimeInfo} snapshot
+         *    (from `symbol`, `context`, `backtest`) and invokes `entry.handler(info)`
+         *    — store the promise, and `await` it. The slot is removed in `.finally()`
+         *    so the next boundary creates a fresh promise; for fire-once entries the
+         *    fired-once key is also added to `_firedOnce` on success so subsequent
+         *    ticks skip it.
+         * 7. After `await Promise.all`, roll back the watermark for every **periodic**
+         *    slot this tick *opened* (not the ones whose in-flight promise it reused)
+         *    whose handler reported failure, so the next tick re-opens and re-runs
+         *    that boundary.
          *
          * Errors thrown by `handler` are caught, logged via `console.error`, and
          * **not** rethrown — a failing handler must not break the per-symbol
          * tick loop or unblock other parallel backtests with an unhandled
          * rejection. A failed fire-once handler is **not** marked as fired and
-         * will retry on the next tick.
+         * will retry on the next tick. A failed **periodic** handler likewise
+         * retries: the boundary watermark advanced at slot-open time is rolled back
+         * after the slot settles (step 7), so the next tick re-opens that boundary.
          *
          * Requires active method context and execution context.
          *
          * @param symbol - Trading symbol from the current tick.
          * @param when - Virtual time of the current tick.
          * @param backtest - `true` for backtest ticks, `false` for live ticks.
-         *   Forwarded as the third argument to `entry.handler`. Only the value
-         *   from the tick that **opens** a given slot is observed by all parallel
-         *   awaiters of that slot.
+         *   Forwarded to {@link _runEntry} and surfaced as `info.backtest`. Only the
+         *   value from the tick that **opens** a given slot is observed by all
+         *   parallel awaiters of that slot.
+         * @param context - Strategy/exchange/frame identifiers from the originating
+         *   lifecycle event, forwarded to `RuntimeMetaService.getRuntimeInfo` to
+         *   build the {@link IRuntimeInfo} snapshot passed to the handler.
          * @throws Error if method or execution context is missing.
          */
-        this._tick = async (symbol, when, backtest) => {
+        this._tick = async (symbol, when, backtest, context) => {
             LOGGER_SERVICE$1.debug(CRON_METHOD_NAME_TICK, {
                 symbol,
                 when,
+                context,
             });
             if (!MethodContextService.hasContext()) {
                 throw new Error("CronUtils _tick requires method context");
@@ -64932,6 +65292,10 @@ class CronUtils {
             }
             const ts = alignToInterval(when, "1m").getTime();
             const taskList = [];
+            // Periodic slots THIS tick actually opened (the `!pending` branch), tracked
+            // for watermark rollback on failure. See {@link IOpenedSlot} for what is and
+            // is not recorded here and why.
+            const openedList = [];
             for (const { entry, generation } of this._entries.values()) {
                 if (entry.symbols?.length && !entry.symbols.includes(symbol)) {
                     continue;
@@ -64939,7 +65303,6 @@ class CronUtils {
                 const perSymbol = !!entry.symbols?.length;
                 const scope = perSymbol ? `:${symbol}` : "";
                 const genSuffix = `:g${generation}`;
-                let aligned;
                 let alignedMs;
                 let slotKey;
                 let firedKey;
@@ -64951,15 +65314,13 @@ class CronUtils {
                     if (this._firedOnce.has(onceKey)) {
                         continue;
                     }
-                    aligned = alignToInterval(when, "1m");
                     alignedMs = ts;
                     slotKey = `${entry.name}:once${scope}${genSuffix}`;
                     firedKey = onceKey;
                     boundaryKey = null;
                 }
                 else {
-                    aligned = alignToInterval(when, entry.interval);
-                    alignedMs = aligned.getTime();
+                    alignedMs = alignToInterval(when, entry.interval).getTime();
                     boundaryKey = `${entry.name}${scope}${genSuffix}`;
                     const lastBoundary = this._lastBoundary.get(boundaryKey);
                     // Fire when the tick's aligned boundary has advanced past the last one
@@ -64977,16 +65338,70 @@ class CronUtils {
                     // Advance the watermark synchronously at slot-open time, before the
                     // await below. Otherwise a later tick on the same (or an already
                     // crossed) boundary, arriving while this handler is still in flight,
-                    // would see the stale watermark and open a duplicate slot.
+                    // would see the stale watermark and open a duplicate slot. The advance
+                    // is rolled back after the slot settles if the handler failed (see the
+                    // post-await loop below), so a failed boundary is retried next tick.
                     if (boundaryKey !== null) {
+                        // Capture the pre-advance value so it can be restored verbatim on
+                        // failure (undefined => the boundary had never opened => delete the
+                        // key on rollback). Read fresh here rather than reusing `lastBoundary`
+                        // above to keep the value↔slot binding local and obvious; there is no
+                        // `await` between the two reads, so they are identical.
+                        const prevBoundary = this._lastBoundary.get(boundaryKey);
                         this._lastBoundary.set(boundaryKey, alignedMs);
+                        pending = this._runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context);
+                        this._inFlight.set(slotKey, pending);
+                        openedList.push({ boundaryKey, prevBoundary, pending });
+                    }
+                    else {
+                        pending = this._runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context);
+                        this._inFlight.set(slotKey, pending);
                     }
-                    pending = this._runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest);
-                    this._inFlight.set(slotKey, pending);
                 }
                 taskList.push(pending);
             }
-            await Promise.all(taskList);
+            {
+                // Watchdog: warn (do not interrupt) if the slots this tick is awaiting
+                // have not settled within CRON_HANDLER_TIMEOUT. We deliberately keep
+                // awaiting Promise.all so the singlerun pipeline stays serialised and no
+                // duplicate/zombie slots are spawned — the timer only surfaces the stall.
+                // Use a real setTimeout/clearTimeout (not sleep) so the alarm is cancelled
+                // the instant Promise.all resolves, rather than lingering for the full
+                // timeout on every fast tick.
+                const timer = setTimeout(() => {
+                    const message = `${CRON_METHOD_NAME_TICK} timed out after ${CRON_HANDLER_TIMEOUT}ms`;
+                    const payload = { symbol, when, context };
+                    LOGGER_SERVICE$1.warn(message, payload);
+                    console.error(message, payload);
+                    errorEmitter.next(new Error(message));
+                }, CRON_HANDLER_TIMEOUT);
+                try {
+                    await Promise.all(taskList);
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
+            // Roll back the watermark for any periodic slot THIS tick opened whose
+            // handler failed, so the next tick re-opens the same boundary and retries
+            // it — mirroring how a skipped boundary is later caught up. Restoring
+            // `prevBoundary` (or deleting the key when it was `undefined`) re-arms the
+            // strict-`>` gate without disturbing any earlier already-fired boundary.
+            // `await pending` is cheap — every promise already settled in `Promise.all`
+            // above; we re-await via `openedList` because its entries (opened slots
+            // only) do not line up with `taskList` indices.
+            for (const { boundaryKey, prevBoundary, pending } of openedList) {
+                const failed = await pending;
+                if (!failed) {
+                    continue;
+                }
+                if (prevBoundary === undefined) {
+                    this._lastBoundary.delete(boundaryKey);
+                }
+                else {
+                    this._lastBoundary.set(boundaryKey, prevBoundary);
+                }
+            }
         };
         /**
          * Subscribe `Cron` to the engine's strategy lifecycle subjects so registered
@@ -65001,7 +65416,11 @@ class CronUtils {
          *
          * All four subjects are subscribed to a single `singlerun`-wrapped
          * handler that builds `_tick(event.symbol, new Date(event.timestamp),
-         * event.backtest)`. `singlerun` merges the four streams into one serial
+         * event.backtest, { strategyName, exchangeName, frameName })`. The context
+         * object is read uniformly from the event — every contract carries
+         * `strategyName`, `exchangeName` and `frameName` at the top level (Active /
+         * Schedule contracts gained `frameName` for exactly this reason), so no
+         * per-event branching is needed. `singlerun` merges the four streams into one serial
          * queue: at most one `_tick` runs at a time, the next waits. This matters
          * because the engine can emit `beforeStart` and an immediate `idlePing`
          * on the very same minute, and concurrent `_tick`s on the same
@@ -65037,7 +65456,11 @@ class CronUtils {
         this.enable = functoolsKit.singleshot(() => {
             LOGGER_SERVICE$1.info(CRON_METHOD_NAME_ENABLE);
             const handleTick = functoolsKit.singlerun(async (event) => {
-                return await this._tick(event.symbol, new Date(event.timestamp), event.backtest);
+                return await this._tick(event.symbol, new Date(event.timestamp), event.backtest, {
+                    strategyName: event.strategyName,
+                    exchangeName: event.exchangeName,
+                    frameName: event.frameName,
+                });
             });
             const unBeforeStart = beforeStartSubject.subscribe(handleTick);
             const unIdlePing = idlePingSubject.subscribe(handleTick);
@@ -65140,25 +65563,51 @@ class CronUtils {
     /**
      * Build the singleshot promise for a single in-flight slot.
      *
-     * Invokes `entry.handler(symbol, aligned, backtest)`, swallows and logs
-     * any error via `console.error`, and clears the `_inFlight` slot
-     * in `.finally()` so the next boundary produces a fresh promise. For
-     * fire-once entries `firedKey` is added to `_firedOnce` on success so
-     * subsequent ticks skip it.
-     *
+     * Assembles the {@link IRuntimeInfo} snapshot via
+     * `RuntimeMetaService.getRuntimeInfo(symbol, context, backtest)` and invokes
+     * `entry.handler(info)`. Logs any error via `console.error` and **returns** a
+     * `failed` boolean (`true` when the handler — or the runtime-info assembly —
+     * threw) so the caller (`_tick`) can roll back the periodic watermark of the
+     * slot it opened and retry that boundary. The error is **not** rethrown, so a
+     * failing handler never produces an unhandled rejection. Clears the
+     * `_inFlight` slot in `.finally()` so the next boundary produces a fresh
+     * promise. For fire-once entries `firedKey` is added to `_firedOnce` on
+     * success so subsequent ticks skip it.
+     *
+     * `getRuntimeInfo` is the user-facing aggregator: its sub-fetches (range,
+     * info, price) are individually wrapped in `trycatch` with `null` fallbacks,
+     * so it almost never throws for missing data. Whatever does throw — the
+     * handler, or in rare cases `getRuntimeInfo` — is caught here and reported via
+     * the returned `failed` flag; the watermark rollback treats both identically.
+     *
+     * @param context - Strategy/exchange/frame identifiers from the originating
+     *   lifecycle event, forwarded to `getRuntimeInfo` to resolve `range`/`info`.
      * @param firedKey - Key to add to `_firedOnce` on success, or `null` for
      *   periodic entries (which never populate `_firedOnce`).
-     * @param backtest - Value forwarded as the third handler argument; the
-     *   "winner" tick's flag is what all parallel awaiters of this slot see.
+     * @param backtest - Forwarded to `getRuntimeInfo` and surfaced as
+     *   `info.backtest`; the "winner" tick's flag is what all parallel awaiters
+     *   of this slot see.
+     * @returns `true` if the handler (or `getRuntimeInfo`) threw, `false` on
+     *   success. `_tick` uses this to decide whether to roll back the watermark.
      */
-    async _runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest) {
+    async _runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context) {
         let failed = false;
         try {
-            await entry.handler(symbol, aligned, backtest);
+            const info = await RUNTIME_META_SERVICE.getRuntimeInfo(symbol, context, backtest);
+            await entry.handler(info);
         }
-        catch (err) {
+        catch (error) {
             failed = true;
-            console.error(`${CRON_METHOD_NAME_TICK} entry "${entry.name}" failed`, { symbol, alignedMs, err });
+            const message = `${CRON_METHOD_NAME_TICK} entry "${entry.name}" failed`;
+            const payload = {
+                symbol,
+                alignedMs,
+                error: functoolsKit.errorData(error),
+                message: functoolsKit.getErrorMessage(error),
+            };
+            LOGGER_SERVICE$1.warn(message, payload);
+            console.error(message, payload);
+            errorEmitter.next(error);
         }
         finally {
             this._inFlight.delete(slotKey);
@@ -65166,6 +65615,7 @@ class CronUtils {
                 this._firedOnce.add(firedKey);
             }
         }
+        return failed;
     }
 }
 /**
@@ -65179,7 +65629,7 @@ class CronUtils {
  * Cron.register({
  *   name: "tg-parser",
  *   interval: "1h",
- *   handler: async (symbol, when, backtest) => { ... },
+ *   handler: async (info) => { ... },
  * });
  * ```
  */
@@ -66528,6 +66978,7 @@ exports.getPositionPnlPercent = getPositionPnlPercent;
 exports.getPositionWaitingMinutes = getPositionWaitingMinutes;
 exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;
+exports.getRuntimeInfo = getRuntimeInfo;
 exports.getScheduledSignal = getScheduledSignal;
 exports.getSessionData = getSessionData;
 exports.getSignalState = getSignalState;