@tradejs/cli 3.1.10 → 3.1.11-beta.216

package/dist/cli.js

@@ -12182,7 +12182,7 @@ var init_marketContextPrepare = __esm({
 });
 
 // src/lib/runtimeRedis.ts
-var import_redis4, import_time, import_runtimeStrategyConfigs, isRuntimeStrategyEnabled, isRuntimeTradeRecord, loadRuntimeTrades, loadRuntimeClosedTrades, loadRuntimeActiveTradeOrderIds, loadStrategyResultSymbols;
+var import_redis4, import_time, import_runtimeStrategyConfigs, isRuntimeStrategyEnabled, isRuntimeTradeRecord, loadRuntimeTrades, loadRuntimeClosedTrades, loadRuntimeActiveTradeOrderIds, loadRuntimeActiveTrades, loadStrategyResultSymbols;
 var init_runtimeRedis = __esm({
   "src/lib/runtimeRedis.ts"() {
     "use strict";
@@ -12267,6 +12267,17 @@ var init_runtimeRedis = __esm({
         ).filter((orderId) => orderId != null)
       );
     };
+    loadRuntimeActiveTrades = async (userName3) => {
+      const orderIds = await loadRuntimeActiveTradeOrderIds(userName3);
+      const trades = await Promise.all(
+        [...orderIds].map(
+          (orderId) => (0, import_redis4.getData)(import_redis4.redisKeys.runtimeTrade(userName3, orderId), null)
+        )
+      );
+      return trades.filter(
+        (trade) => isRuntimeTradeRecord(trade) && trade.status === "active"
+      );
+    };
     loadStrategyResultSymbols = async ({
       userName: userName3,
       strategy
@@ -12689,7 +12700,7 @@ var init_tickerUniverseCache = __esm({
 });
 
 // src/lib/runEnvironment.ts
-var import_chalk12, import_connectors5, import_cli4, import_constants6, import_time2, import_runtimeStrategies, timeOperation2, resolveBacktestExecutionPreloadInterval, resolveRunConnectorName, loadDeploymentReplayStrategies, prepareRunEnvironment;
+var import_chalk12, import_connectors5, import_cli4, import_constants6, import_time2, import_runtimeStrategies, timeOperation2, resolveBacktestExecutionPreloadInterval, resolveRunConnectorName, mergeRuntimeStrategySelections, loadDeploymentReplayStrategies, prepareRunEnvironment;
 var init_runEnvironment = __esm({
   "src/lib/runEnvironment.ts"() {
     "use strict";
@@ -12734,6 +12745,18 @@ var init_runEnvironment = __esm({
       );
       return import_connectors5.DEFAULT_CONNECTOR_NAME;
     };
+    mergeRuntimeStrategySelections = (strategies) => {
+      if (strategies.some((strategy) => !strategy.selection?.tickers)) {
+        return void 0;
+      }
+      return {
+        tickers: [
+          ...new Set(
+            strategies.flatMap((strategy) => strategy.selection?.tickers ?? [])
+          )
+        ]
+      };
+    };
     loadDeploymentReplayStrategies = async ({
       userName: userName3,
       projectRoot: projectRoot15,
@@ -12753,14 +12776,16 @@ var init_runEnvironment = __esm({
           strategyPackage,
           strategyPackageVersion,
           runtimePackageVersion,
-          sourceStrategyConfig
+          sourceStrategyConfig,
+          selection
         }) => ({
           strategyName,
           version,
           strategyPackage,
           strategyPackageVersion,
           runtimePackageVersion,
-          strategyConfig: sourceStrategyConfig
+          strategyConfig: sourceStrategyConfig,
+          ...selection ? { selection } : {}
         })
       ) : [];
       if (!strategies.length) {
@@ -13705,7 +13730,7 @@ var init_runnerCore = __esm({
       }
       return deployment;
     };
-    prepareRunEnvironment2 = async () => {
+    prepareRunEnvironment2 = async (strategyName) => {
       const deployment = validateBacktestRuntimeDeployment({
         deployment: flags5.deployment ? await (0, import_runtimeStrategies2.getRuntimeDeployment)({
           userName,
@@ -13714,10 +13739,13 @@ var init_runnerCore = __esm({
         }) : null,
         deploymentId: typeof flags5.deployment === "string" ? flags5.deployment : void 0
       });
+      const runtimeStrategy = strategyName ? deployment?.strategies.find(
+        (strategy) => strategy.strategyName === strategyName
+      ) : void 0;
       const preparedRun = await prepareRunEnvironment({
         connector: deployment?.connectorName ?? flags5.connector,
         userName,
-        tickers: flags5.tickers || deployment?.tickers?.join(","),
+        tickers: flags5.tickers || runtimeStrategy?.selection?.tickers?.join(",") || deployment?.tickers?.join(","),
         exclude: flags5.exclude,
         tickersLimit: flags5.tickersLimit,
         showTickersList: flags5.showTickersList,
@@ -14420,7 +14448,7 @@ var init_backtest = __esm({
         });
         return;
       }
-      const preparedRun = await prepareRunEnvironment2();
+      const preparedRun = await prepareRunEnvironment2(config2.strategyName);
       if (!preparedRun || flags5.updateOnly) {
         return;
       }
@@ -25539,7 +25567,7 @@ var init_runtimeLineage = __esm({
 });
 
 // src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies3, isRecord, isNonEmptyString, INTERVALS, UNIVERSES, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
+var import_runtimeStrategies3, isRecord, isNonEmptyString, INTERVALS, UNIVERSES, isRuntimeStrategySelection, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
 var init_runtimeEvidenceDeployment = __esm({
   "src/lib/runtimeEvidenceDeployment.ts"() {
     "use strict";
@@ -25562,6 +25590,7 @@ var init_runtimeEvidenceDeployment = __esm({
       "M"
     ]);
     UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+    isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
     parseRuntimeEvidenceDeploymentSnapshot = (value) => {
       if (!isRecord(value) || value.schemaVersion !== 1 || !isNonEmptyString(value.id) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
         throw new Error(
@@ -25569,7 +25598,7 @@ var init_runtimeEvidenceDeployment = __esm({
         );
       }
       const strategies = value.strategies.map((candidate) => {
-        if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig)) {
+        if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
           throw new Error(
             "Runtime evidence deployment strategy snapshot is invalid"
           );
@@ -25609,11 +25638,12 @@ var init_runtimeEvidenceDeployment = __esm({
       accountId: deployment.accountId,
       enabled: deployment.enabled,
       strategies: deployment.strategies.map(
-        ({ strategyName, version, enabled, controlState }) => ({
+        ({ strategyName, version, enabled, controlState, selection }) => ({
           strategyName,
           version,
           enabled,
-          controlState
+          controlState,
+          ...selection ? { selection } : {}
         })
       ),
       ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
@@ -25651,7 +25681,8 @@ var init_runtimeEvidenceDeployment = __esm({
             strategyPackage,
             strategyPackageVersion,
             runtimePackageVersion,
-            sourceStrategyConfig
+            sourceStrategyConfig,
+            selection
           }) => ({
             strategyName,
             version,
@@ -25663,7 +25694,8 @@ var init_runtimeEvidenceDeployment = __esm({
             strategyPackage,
             strategyPackageVersion,
             runtimePackageVersion,
-            strategyConfig: sourceStrategyConfig
+            strategyConfig: sourceStrategyConfig,
+            ...selection ? { selection } : {}
           })
         ),
         ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
@@ -32352,12 +32384,29 @@ var init_tickerEvaluator = __esm({
 });
 
 // src/lib/signals/configuredScopes.ts
-var sorted, formatConfiguredStrategyIdentity, buildConfiguredSignalsScopes;
+var sorted, formatConfiguredStrategyIdentity, getConfiguredScopeActiveSymbols, buildConfiguredSignalsScopes;
 var init_configuredScopes = __esm({
   "src/lib/signals/configuredScopes.ts"() {
     "use strict";
     sorted = (values) => values ? [...values].sort() : [];
     formatConfiguredStrategyIdentity = (strategy) => `${strategy.strategyName}@v${strategy.version}[${strategy.controlState}]`;
+    getConfiguredScopeActiveSymbols = ({
+      trades,
+      deploymentId,
+      strategyNames,
+      universe,
+      accountId,
+      interval: interval4
+    }) => {
+      const strategyNameSet = new Set(strategyNames);
+      return [
+        ...new Set(
+          trades.filter(
+            (trade) => trade.status === "active" && trade.deploymentId === deploymentId && strategyNameSet.has(trade.strategy) && (trade.universe ?? "crypto") === universe && (!trade.accountId || trade.accountId === accountId) && (!trade.interval || String(trade.interval) === String(interval4))
+          ).map(({ symbol }) => symbol)
+        )
+      ].sort();
+    };
     buildConfiguredSignalsScopes = ({
       connectorName,
       deployment,
@@ -32374,21 +32423,30 @@ var init_configuredScopes = __esm({
       });
       const groups = /* @__PURE__ */ new Map();
       for (const strategy of strategies) {
+        const selectionIdentity = JSON.stringify({
+          tickers: sorted(strategy.selection?.tickers)
+        });
         const baseKey = [
           connectorName,
           strategy.universe,
           strategy.accountId ?? "default",
-          strategy.interval
+          strategy.interval,
+          selectionIdentity
         ].join(":");
         const group = groups.get(baseKey) ?? {
           scope: {
             connectorName,
             universe: strategy.universe,
             accountId: strategy.accountId,
-            interval: strategy.interval
+            interval: strategy.interval,
+            strategyNames: [],
+            ...strategy.selection ? {
+              selection: { tickers: [...strategy.selection.tickers] }
+            } : {}
           },
           strategyIdentities: []
         };
+        group.scope.strategyNames.push(strategy.strategyName);
         group.strategyIdentities.push(formatConfiguredStrategyIdentity(strategy));
         groups.set(baseKey, group);
       }
@@ -32396,7 +32454,10 @@ var init_configuredScopes = __esm({
         key: [baseKey, deploymentIdentity, ...group.strategyIdentities.sort()].join(
           ":"
         ),
-        scope: group.scope
+        scope: {
+          ...group.scope,
+          strategyNames: [...group.scope.strategyNames].sort()
+        }
       }));
     };
   }
@@ -32419,6 +32480,7 @@ var init_runner = __esm({
     import_runtimeHeartbeats = require("@tradejs/infra/runtimeHeartbeats");
     import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
     init_windows();
+    init_runtimeRedis();
     init_runFormatting();
     init_hooks();
     init_marketContextPrepare();
@@ -32540,6 +32602,10 @@ var init_runner = __esm({
           interval: runtimeInterval,
           intervalMs: runtimeIntervalMs,
           deployment,
+          ...scope.strategyNames ? { strategyNames: [...scope.strategyNames] } : {},
+          ...scope.selection ? {
+            selection: { tickers: [...scope.selection.tickers] }
+          } : {},
           startedAt: Date.now(),
           marketConnector,
           btcReferences,
@@ -32569,13 +32635,31 @@ var init_runner = __esm({
             btcReferences,
             lifecycle,
             interval: interval5,
-            intervalMs
+            intervalMs,
+            strategyNames,
+            selection
           } = session;
           const universe = sessionUniverse ?? marketConnector.universe ?? "crypto";
+          const selectedActiveSymbols = !config2.tickers && selection?.tickers?.length && strategyNames?.length ? getConfiguredScopeActiveSymbols({
+            trades: await loadRuntimeActiveTrades(config2.userName),
+            deploymentId: deployment?.id ?? "",
+            strategyNames,
+            universe,
+            accountId,
+            interval: interval5
+          }) : [];
+          const selectedTickers = selection?.tickers ? [.../* @__PURE__ */ new Set([...selection.tickers, ...selectedActiveSymbols])] : void 0;
+          if (selectedActiveSymbols.length) {
+            import_logger10.logger.info(
+              import_chalk45.default.gray(
+                `strategy selection retained active symbols: ${selectedActiveSymbols.join(", ")}`
+              )
+            );
+          }
           const tickers = await timeOperation3("tickers load", () => {
             const baseArgs = [
               marketConnector,
-              config2.tickers || deployment?.tickers?.join(","),
+              config2.tickers || selectedTickers?.join(",") || deployment?.tickers?.join(","),
               config2.exclude,
               config2.tickersLimit,
               config2.chunk
@@ -32718,7 +32802,7 @@ var init_runner = __esm({
           const primaryEthByTimestamp = new Map(
             primaryEthClosedData.map((candle) => [candle.timestamp, candle])
           );
-          const runtimeStrategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
+          const configuredRuntimeStrategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
             userName: config2.userName,
             projectRoot: projectRoot15,
             deploymentId: deployment?.id ?? "",
@@ -32726,6 +32810,10 @@ var init_runner = __esm({
             accountId,
             interval: interval5
           });
+          const selectedStrategyNames = strategyNames?.length ? new Set(strategyNames) : null;
+          const runtimeStrategies = selectedStrategyNames ? configuredRuntimeStrategies.filter(
+            ({ strategyName }) => selectedStrategyNames.has(strategyName)
+          ) : configuredRuntimeStrategies;
           if (!runtimeStrategies.length) {
             lifecycle.clear();
             import_logger10.logger.warn(
@@ -33911,7 +33999,7 @@ var init_portfolioReplayConnector = __esm({
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
-var import_chalk46, import_progress12, import_backtest4, import_strategies13, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies14, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
+var import_chalk46, import_progress12, import_backtest4, import_strategies13, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies14, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, strategyIncludesSymbol, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
 var init_historicalSignalsReplay = __esm({
   "src/lib/replay/historicalSignalsReplay.ts"() {
     "use strict";
@@ -33941,7 +34029,8 @@ var init_historicalSignalsReplay = __esm({
             strategyPackage,
             strategyPackageVersion,
             runtimePackageVersion,
-            strategyConfig
+            strategyConfig,
+            selection
           } = runtimeStrategy;
           const strategyCreator = await (0, import_strategies14.getStrategyCreator)(
             strategyName,
@@ -33971,7 +34060,8 @@ var init_historicalSignalsReplay = __esm({
             runtimePackageVersion,
             strategyCreator,
             strategyConfig,
-            strategyResults
+            strategyResults,
+            ...selection ? { selection } : {}
           };
         })
       );
@@ -34056,6 +34146,14 @@ var init_historicalSignalsReplay = __esm({
         })
       )
     });
+    strategyIncludesSymbol = (strategy, symbol) => {
+      const tickers = strategy.selection?.tickers;
+      if (!tickers) return true;
+      const normalizedSymbol = symbol.trim().toUpperCase();
+      return tickers.some(
+        (ticker) => ticker.trim().toUpperCase() === normalizedSymbol
+      );
+    };
     buildSymbolSharedReplayKey = ({
       connectorName,
       interval: interval4,
@@ -34159,7 +34257,7 @@ var init_historicalSignalsReplay = __esm({
         });
         sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
         const strategiesForSymbol = await Promise.all(
-          loadedStrategies.map(
+          loadedStrategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(
             async ({
               strategyName,
               version,
@@ -37207,14 +37305,16 @@ var init_replayRunner = __esm({
             strategyPackage,
             strategyPackageVersion,
             runtimePackageVersion,
-            strategyConfig
+            strategyConfig,
+            selection
           }) => ({
             strategyName,
             version,
             strategyPackage,
             strategyPackageVersion,
             runtimePackageVersion,
-            strategyConfig
+            strategyConfig,
+            ...selection ? { selection } : {}
           })
         )
       } : await loadDeploymentReplayStrategies({
@@ -37246,10 +37346,11 @@ var init_replayRunner = __esm({
           `Replay requires one deployment universe: ${[...strategyUniverses].join(",")}`
         );
       }
+      const replaySelection = mergeRuntimeStrategySelections(replayStrategies);
       const preparedRun = await prepareRunEnvironment({
         connector: deployment.connectorName,
         userName: replayUserName,
-        tickers: replayFlags.tickers ?? deployment.tickers,
+        tickers: replayFlags.tickers ?? replaySelection?.tickers?.join(",") ?? deployment.tickers?.join(","),
         exclude: replayFlags.exclude,
         tickersLimit: replayFlags.tickersLimit,
         showTickersList: replayFlags.showTickersList,
@@ -37297,7 +37398,9 @@ var init_replayRunner = __esm({
       const replayResult = await runHistoricalSignalsReplay({
         preparedRun,
         interval: replayInterval,
-        runtimeStrategies: replayStrategies
+        runtimeStrategies: replayFlags.tickers ? replayStrategies.map(
+          ({ selection: _selection, ...strategy }) => strategy
+        ) : replayStrategies
       });
       for (const _strategy of replayResult.strategies) {
         incrementSuccessTests();

package/dist/lib/runEnvironment.js

@@ -32,6 +32,7 @@ var runEnvironment_exports = {};
 __export(runEnvironment_exports, {
   loadDeploymentReplayStrategies: () => loadDeploymentReplayStrategies,
   loadReplayStrategies: () => loadReplayStrategies,
+  mergeRuntimeStrategySelections: () => mergeRuntimeStrategySelections,
   prepareRunEnvironment: () => prepareRunEnvironment,
   resolveBacktestExecutionPreloadInterval: () => resolveBacktestExecutionPreloadInterval
 });
@@ -484,6 +485,18 @@ var resolveRunConnectorName = async ({
   );
   return import_connectors3.DEFAULT_CONNECTOR_NAME;
 };
+var mergeRuntimeStrategySelections = (strategies) => {
+  if (strategies.some((strategy) => !strategy.selection?.tickers)) {
+    return void 0;
+  }
+  return {
+    tickers: [
+      ...new Set(
+        strategies.flatMap((strategy) => strategy.selection?.tickers ?? [])
+      )
+    ]
+  };
+};
 var loadReplayStrategies = async (userName) => {
   const runtimeStrategies = await loadRuntimeStrategyBacktestConfigs(userName);
   if (!runtimeStrategies.length) {
@@ -514,14 +527,16 @@ var loadDeploymentReplayStrategies = async ({
       strategyPackage,
       strategyPackageVersion,
       runtimePackageVersion,
-      sourceStrategyConfig
+      sourceStrategyConfig,
+      selection
     }) => ({
       strategyName,
       version,
       strategyPackage,
       strategyPackageVersion,
       runtimePackageVersion,
-      strategyConfig: sourceStrategyConfig
+      strategyConfig: sourceStrategyConfig,
+      ...selection ? { selection } : {}
     })
   ) : [];
   if (!strategies.length) {
@@ -679,6 +694,7 @@ var prepareRunEnvironment = async ({
 0 && (module.exports = {
   loadDeploymentReplayStrategies,
   loadReplayStrategies,
+  mergeRuntimeStrategySelections,
   prepareRunEnvironment,
   resolveBacktestExecutionPreloadInterval
 });

package/dist/lib/runtimeEvidenceDeployment.js

@@ -45,6 +45,7 @@ var INTERVALS = /* @__PURE__ */ new Set([
   "M"
 ]);
 var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
 var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
   if (!isRecord(value) || value.schemaVersion !== 1 || !isNonEmptyString(value.id) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
     throw new Error(
@@ -52,7 +53,7 @@ var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
     );
   }
   const strategies = value.strategies.map((candidate) => {
-    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig)) {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
       throw new Error(
         "Runtime evidence deployment strategy snapshot is invalid"
       );
@@ -92,11 +93,12 @@ var runtimeDeploymentFromEvidence = (deployment) => ({
   accountId: deployment.accountId,
   enabled: deployment.enabled,
   strategies: deployment.strategies.map(
-    ({ strategyName, version, enabled, controlState }) => ({
+    ({ strategyName, version, enabled, controlState, selection }) => ({
       strategyName,
       version,
       enabled,
-      controlState
+      controlState,
+      ...selection ? { selection } : {}
     })
   ),
   ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
@@ -134,7 +136,8 @@ var resolveRuntimeEvidenceDeploymentSnapshot = async ({
         strategyPackage,
         strategyPackageVersion,
         runtimePackageVersion,
-        sourceStrategyConfig
+        sourceStrategyConfig,
+        selection
       }) => ({
         strategyName,
         version,
@@ -146,7 +149,8 @@ var resolveRuntimeEvidenceDeploymentSnapshot = async ({
         strategyPackage,
         strategyPackageVersion,
         runtimePackageVersion,
-        strategyConfig: sourceStrategyConfig
+        strategyConfig: sourceStrategyConfig,
+        ...selection ? { selection } : {}
       })
     ),
     ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},

package/dist/lib/runtimeRedis.js

@@ -24,6 +24,7 @@ __export(runtimeRedis_exports, {
   isRuntimeStrategyEnabled: () => isRuntimeStrategyEnabled,
   isRuntimeTradeRecord: () => isRuntimeTradeRecord,
   loadRuntimeActiveTradeOrderIds: () => loadRuntimeActiveTradeOrderIds,
+  loadRuntimeActiveTrades: () => loadRuntimeActiveTrades,
   loadRuntimeClosedTrades: () => loadRuntimeClosedTrades,
   loadRuntimeStrategyConfigs: () => import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs,
   loadRuntimeStrategyNames: () => import_runtimeStrategyConfigs.loadRuntimeStrategyNames,
@@ -114,6 +115,17 @@ var loadRuntimeActiveTradeOrderIds = async (userName) => {
     ).filter((orderId) => orderId != null)
   );
 };
+var loadRuntimeActiveTrades = async (userName) => {
+  const orderIds = await loadRuntimeActiveTradeOrderIds(userName);
+  const trades = await Promise.all(
+    [...orderIds].map(
+      (orderId) => (0, import_redis.getData)(import_redis.redisKeys.runtimeTrade(userName, orderId), null)
+    )
+  );
+  return trades.filter(
+    (trade) => isRuntimeTradeRecord(trade) && trade.status === "active"
+  );
+};
 var loadStrategyResultSymbols = async ({
   userName,
   strategy
@@ -132,6 +144,7 @@ var loadStrategyResultSymbols = async ({
   isRuntimeStrategyEnabled,
   isRuntimeTradeRecord,
   loadRuntimeActiveTradeOrderIds,
+  loadRuntimeActiveTrades,
   loadRuntimeClosedTrades,
   loadRuntimeStrategyConfigs,
   loadRuntimeStrategyNames,

package/dist/scripts/backtest.js

@@ -5024,7 +5024,7 @@ var validateBacktestRuntimeDeployment = ({
   }
   return deployment;
 };
-var prepareRunEnvironment2 = async () => {
+var prepareRunEnvironment2 = async (strategyName) => {
   const deployment = validateBacktestRuntimeDeployment({
     deployment: flags.deployment ? await (0, import_runtimeStrategies2.getRuntimeDeployment)({
       userName,
@@ -5033,10 +5033,13 @@ var prepareRunEnvironment2 = async () => {
     }) : null,
     deploymentId: typeof flags.deployment === "string" ? flags.deployment : void 0
   });
+  const runtimeStrategy = strategyName ? deployment?.strategies.find(
+    (strategy) => strategy.strategyName === strategyName
+  ) : void 0;
   const preparedRun = await prepareRunEnvironment({
     connector: deployment?.connectorName ?? flags.connector,
     userName,
-    tickers: flags.tickers || deployment?.tickers?.join(","),
+    tickers: flags.tickers || runtimeStrategy?.selection?.tickers?.join(",") || deployment?.tickers?.join(","),
     exclude: flags.exclude,
     tickersLimit: flags.tickersLimit,
     showTickersList: flags.showTickersList,
@@ -5693,7 +5696,7 @@ var backtest = async () => {
     });
     return;
   }
-  const preparedRun = await prepareRunEnvironment2();
+  const preparedRun = await prepareRunEnvironment2(config.strategyName);
   if (!preparedRun || flags.updateOnly) {
     return;
   }