@tradejs/cli 3.1.2 → 3.1.4

package/dist/cli.js

@@ -13668,8 +13668,7 @@ var init_runnerCore = __esm({
     };
     validateBacktestRuntimeDeployment = ({
       deployment,
-      deploymentId,
-      requestedInterval
+      deploymentId
     }) => {
       if (deploymentId && !deployment) {
         throw new Error(`Runtime deployment not found: ${deploymentId}`);
@@ -13677,18 +13676,12 @@ var init_runnerCore = __esm({
       if (deployment && !deployment.enabled) {
         throw new Error(`Runtime deployment is disabled: ${deployment.id}`);
       }
-      if (deployment && String(deployment.interval) !== String(requestedInterval)) {
-        throw new Error(
-          `Deployment ${deployment.id} requires timeframe ${deployment.interval}; received ${requestedInterval}`
-        );
-      }
       return deployment;
     };
     prepareRunEnvironment2 = async () => {
       const deployment = validateBacktestRuntimeDeployment({
         deployment: flags5.deployment ? await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, String(flags5.deployment)) : null,
-        deploymentId: typeof flags5.deployment === "string" ? flags5.deployment : void 0,
-        requestedInterval: interval
+        deploymentId: typeof flags5.deployment === "string" ? flags5.deployment : void 0
       });
       const preparedRun = await prepareRunEnvironment({
         connector: deployment?.connectorName ?? flags5.connector,
@@ -13703,7 +13696,7 @@ var init_runnerCore = __esm({
         cacheOnly: flags5.cacheOnly,
         interval,
         projectRoot: projectRoot3,
-        universe: deployment?.universe ?? marketUniverse,
+        universe: marketUniverse,
         accountId: deployment?.accountId ?? flags5.account,
         deploymentId: deployment?.id,
         assetClasses: deployment?.assetClasses,
@@ -14409,15 +14402,7 @@ var init_backtest = __esm({
           preparedRun.connectorName,
           interval
         ).map((test) => {
-          const deploymentStrategy = preparedRun.deployment?.strategies.find(
-            ({ strategyName }) => strategyName === config2.strategyName
-          );
-          if (deploymentStrategy?.enabled === false) {
-            throw new Error(
-              `Strategy ${config2.strategyName} is disabled in deployment ${preparedRun.deployment?.id}`
-            );
-          }
-          const policyProfileId = (typeof flags5.policyProfile === "string" && flags5.policyProfile.trim() ? flags5.policyProfile.trim() : deploymentStrategy?.policyProfileId) || void 0;
+          const policyProfileId = (typeof flags5.policyProfile === "string" && flags5.policyProfile.trim() ? flags5.policyProfile.trim() : void 0) || void 0;
           return {
             ...test,
             instrument: preparedRun.instrumentsBySymbol.get(
@@ -14429,7 +14414,6 @@ var init_backtest = __esm({
             policyProfileId,
             strategyConfig: {
               ...test.strategyConfig,
-              ...deploymentStrategy?.config,
               ...policyProfileId ? { POLICY_PROFILE_ID: policyProfileId } : {}
             }
           };
@@ -28101,23 +28085,35 @@ var init_runtimeScorecard2 = __esm({
 // src/scripts/runtimeConfig.ts
 var runtimeConfig_exports = {};
 __export(runtimeConfig_exports, {
-  buildBootstrapRuntimeDeployment: () => buildBootstrapRuntimeDeployment,
+  RUNTIME_CONFIG_ACTIONS: () => RUNTIME_CONFIG_ACTIONS,
+  buildProvisionedRuntimeDeployment: () => buildProvisionedRuntimeDeployment,
+  isEquivalentRuntimeStrategyRelease: () => isEquivalentRuntimeStrategyRelease,
   main: () => main37,
+  pointRuntimeDeploymentAtRelease: () => pointRuntimeDeploymentAtRelease,
   runtimeConfig: () => runtimeConfig
 });
-var import_config9, import_promises28, import_node_path23, import_runtimeDeployments2, import_runtimeStrategyConfigs2, import_runtimeStrategyReleases, import_runtimeStrategies, import_strategies11, argv, action, option, hasFlag, required2, projectRoot12, userName2, OPERATIONAL_CONFIG_KEYS, toReleaseConfig, writeMigrationBackup, publish, buildBootstrapRuntimeDeployment, bootstrap, migrate, publishDraft, updateControlState, rollback, verify, inspect, runtimeConfig, main37;
+var import_config9, import_promises28, import_node_path23, import_node_util2, import_runtimeDeployments2, import_runtimeStrategyReleases, import_runtimeStrategies, import_strategies11, argv, RUNTIME_CONFIG_ACTIONS, action, option, hasFlag, required2, projectRoot12, userName2, OPERATIONAL_CONFIG_KEYS, requireRuntimePackageIdentity, toReleaseConfig, publish, buildProvisionedRuntimeDeployment, isEquivalentRuntimeStrategyRelease, pointRuntimeDeploymentAtRelease, provision, rollout, updateControlState, rollback, verify, inspect, runtimeConfig, main37;
 var init_runtimeConfig = __esm({
   "src/scripts/runtimeConfig.ts"() {
     "use strict";
     import_config9 = require("dotenv/config");
     import_promises28 = require("fs/promises");
     import_node_path23 = __toESM(require("path"));
+    import_node_util2 = require("util");
     import_runtimeDeployments2 = require("@tradejs/infra/runtimeDeployments");
-    import_runtimeStrategyConfigs2 = require("@tradejs/infra/runtimeStrategyConfigs");
     import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
     import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
     import_strategies11 = require("@tradejs/node/strategies");
     argv = process.argv.slice(2);
+    RUNTIME_CONFIG_ACTIONS = [
+      "inspect",
+      "verify",
+      "provision",
+      "rollout",
+      "pause",
+      "resume",
+      "rollback"
+    ];
     action = argv[0] ?? "inspect";
     option = (name) => {
       const index = argv.indexOf(`--${name}`);
@@ -28138,28 +28134,26 @@ var init_runtimeConfig = __esm({
       "ENABLE",
       "ENV",
       "MAKE_ORDERS",
-      "RECORD_RUNTIME_TRADES",
-      "configId"
+      "RECORD_RUNTIME_TRADES"
     ];
+    requireRuntimePackageIdentity = (strategyName, metadata) => {
+      if (!metadata.strategyPackage || !metadata.strategyPackageVersion || !metadata.runtimePackageVersion) {
+        throw new Error(
+          `Runtime package manifest is incomplete for ${strategyName}`
+        );
+      }
+      return {
+        strategyPackage: metadata.strategyPackage,
+        strategyPackageVersion: metadata.strategyPackageVersion,
+        runtimePackageVersion: metadata.runtimePackageVersion
+      };
+    };
     toReleaseConfig = async (strategyName, sourceConfig) => {
       const defaults = await (0, import_strategies11.getStrategyDefaults)(strategyName, projectRoot12) ?? {};
       const config2 = { ...defaults, ...sourceConfig };
       for (const key of OPERATIONAL_CONFIG_KEYS) delete config2[key];
       return config2;
     };
-    writeMigrationBackup = async (payload) => {
-      const directory = import_node_path23.default.join(projectRoot12, "data", "runtime-config-backups");
-      await (0, import_promises28.mkdir)(directory, { recursive: true });
-      const backupPath = import_node_path23.default.join(
-        directory,
-        `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`
-      );
-      await (0, import_promises28.writeFile)(backupPath, `${JSON.stringify(payload, null, 2)}
-`, {
-        flag: "wx"
-      });
-      return backupPath;
-    };
     publish = async ({
       strategyName,
       sourceConfig
@@ -28169,31 +28163,29 @@ var init_runtimeConfig = __esm({
         strategyName,
         projectRoot: projectRoot12
       });
+      const packageIdentity = requireRuntimePackageIdentity(strategyName, metadata);
       return (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
         userName: userName2,
         strategyName,
         config: config2,
-        ...metadata,
+        ...packageIdentity,
         createdBy: `cli:${userName2}`
       });
     };
-    buildBootstrapRuntimeDeployment = ({
+    buildProvisionedRuntimeDeployment = ({
       deploymentId,
       label,
       connectorName,
       provider,
       accountId,
       strategyName,
-      releaseVersion,
-      config: config2
+      releaseVersion
     }) => ({
       id: deploymentId,
       label,
       connectorName,
       provider,
       accountId,
-      universe: config2.UNIVERSE,
-      interval: String(config2.INTERVAL),
       enabled: true,
       strategies: [
         {
@@ -28203,7 +28195,30 @@ var init_runtimeConfig = __esm({
         }
       ]
     });
-    bootstrap = async () => {
+    isEquivalentRuntimeStrategyRelease = ({
+      release,
+      config: config2,
+      strategyPackage,
+      strategyPackageVersion,
+      runtimePackageVersion
+    }) => Boolean(
+      release && (0, import_node_util2.isDeepStrictEqual)(release.config, config2) && release.strategyPackage === strategyPackage && release.strategyPackageVersion === strategyPackageVersion && release.runtimePackageVersion === runtimePackageVersion
+    );
+    pointRuntimeDeploymentAtRelease = ({
+      deployment,
+      strategyName,
+      releaseVersion
+    }) => ({
+      ...deployment,
+      strategies: deployment.strategies.map(
+        (strategy) => strategy.strategyName === strategyName ? {
+          strategyName,
+          releaseVersion,
+          controlState: "entries_paused"
+        } : strategy
+      )
+    });
+    provision = async () => {
       const strategyName = required2("strategy");
       const deploymentId = required2("deployment");
       const accountId = required2("account");
@@ -28221,15 +28236,14 @@ var init_runtimeConfig = __esm({
         );
       }
       const releaseConfig = await toReleaseConfig(strategyName, sourceConfig);
-      const previewDeployment = buildBootstrapRuntimeDeployment({
+      const previewDeployment = buildProvisionedRuntimeDeployment({
         deploymentId,
         label,
         connectorName,
         provider,
         accountId,
         strategyName,
-        releaseVersion: 1,
-        config: releaseConfig
+        releaseVersion: 1
       });
       if (!hasFlag("write")) {
         console.log(
@@ -28251,102 +28265,103 @@ var init_runtimeConfig = __esm({
         );
         return;
       }
-      const backupPath = await writeMigrationBackup({
-        userName: userName2,
-        capturedAt: Date.now(),
-        reason: "bootstrap",
-        sourceConfig
-      });
       const release = await publish({ strategyName, sourceConfig });
       const deployment = await (0, import_runtimeDeployments2.saveRuntimeDeployment)(
         userName2,
-        buildBootstrapRuntimeDeployment({
+        buildProvisionedRuntimeDeployment({
           deploymentId,
           label,
           connectorName,
           provider,
           accountId,
           strategyName,
-          releaseVersion: release.releaseVersion,
-          config: release.config
+          releaseVersion: release.releaseVersion
         })
       );
       console.log(
-        JSON.stringify(
-          { bootstrapped: true, backupPath, release, deployment },
-          null,
-          2
-        )
+        JSON.stringify({ provisioned: true, release, deployment }, null, 2)
       );
     };
-    migrate = async () => {
+    rollout = async () => {
       const strategyName = required2("strategy");
-      const configId = option("config") ?? "config";
       const deploymentId = required2("deployment");
-      const [sourceConfig, deployment] = await Promise.all([
-        (0, import_runtimeStrategyConfigs2.getRuntimeStrategyConfig)(userName2, strategyName, configId),
-        (0, import_runtimeDeployments2.getRuntimeDeployment)(userName2, deploymentId)
+      const configFile = import_node_path23.default.resolve(projectRoot12, required2("file"));
+      const [deployment, sourceConfig] = await Promise.all([
+        (0, import_runtimeDeployments2.getRuntimeDeployment)(userName2, deploymentId),
+        (0, import_promises28.readFile)(configFile, "utf8").then(
+          (value) => JSON.parse(value)
+        )
       ]);
-      if (!sourceConfig) {
-        throw new Error(`Legacy config not found: ${strategyName}:${configId}`);
-      }
       if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
       const reference = deployment.strategies.find(
         (strategy) => strategy.strategyName === strategyName
       );
-      if (!reference) {
+      if (!reference)
         throw new Error(`${strategyName} is not bound to ${deploymentId}`);
-      }
+      const [config2, metadata, currentRelease] = await Promise.all([
+        toReleaseConfig(strategyName, sourceConfig),
+        (0, import_runtimeStrategies.getRuntimeStrategyPackageMetadata)({ strategyName, projectRoot: projectRoot12 }),
+        (0, import_runtimeStrategyReleases.getRuntimeStrategyRelease)(userName2, strategyName, reference.releaseVersion)
+      ]);
+      const packageIdentity = requireRuntimePackageIdentity(strategyName, metadata);
+      const unchanged = isEquivalentRuntimeStrategyRelease({
+        release: currentRelease,
+        config: config2,
+        ...packageIdentity
+      });
       const preview = {
-        source: { configId, config: sourceConfig },
-        releaseConfig: await toReleaseConfig(strategyName, sourceConfig),
-        deployment: {
-          id: deployment.id,
-          accountId: deployment.accountId,
-          strategy: {
-            strategyName,
-            releaseVersion: "<allocated on write>",
-            controlState: "entries_paused"
-          }
-        }
+        deploymentId,
+        strategyName,
+        currentReleaseVersion: reference.releaseVersion,
+        nextControlState: "entries_paused",
+        unchanged,
+        config: config2,
+        ...packageIdentity
       };
       if (!hasFlag("write")) {
         console.log(JSON.stringify({ dryRun: true, ...preview }, null, 2));
         return;
       }
-      const backupPath = await writeMigrationBackup({
+      if (unchanged) {
+        console.log(
+          JSON.stringify(
+            {
+              rolledOut: false,
+              reason: "release_config_and_packages_unchanged",
+              release: currentRelease,
+              deployment
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      const release = await (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
         userName: userName2,
-        capturedAt: Date.now(),
+        strategyName,
+        config: config2,
+        ...packageIdentity,
+        createdBy: `cli:${userName2}`
+      });
+      const updatedDeployment = pointRuntimeDeploymentAtRelease({
         deployment,
-        legacyConfig: sourceConfig
+        strategyName,
+        releaseVersion: release.releaseVersion
       });
-      const release = await publish({ strategyName, sourceConfig });
-      const updatedDeployment = {
-        ...deployment,
-        strategies: deployment.strategies.map(
-          (strategy) => strategy.strategyName === strategyName ? {
-            strategyName,
-            releaseVersion: release.releaseVersion,
-            controlState: "entries_paused"
-          } : strategy
-        )
-      };
       await (0, import_runtimeDeployments2.saveRuntimeDeployment)(userName2, updatedDeployment);
       console.log(
         JSON.stringify(
-          { migrated: true, backupPath, release, deployment: updatedDeployment },
+          {
+            rolledOut: true,
+            release,
+            deployment: updatedDeployment
+          },
           null,
           2
         )
       );
     };
-    publishDraft = async () => {
-      const strategyName = required2("strategy");
-      const draft = await (0, import_runtimeStrategyReleases.getRuntimeStrategyDraft)(userName2, strategyName);
-      if (!draft) throw new Error(`Draft not found: ${strategyName}`);
-      const release = await publish({ strategyName, sourceConfig: draft.config });
-      console.log(JSON.stringify({ release }, null, 2));
-    };
     updateControlState = async (nextState) => {
       const strategyName = required2("strategy");
       const deploymentId = required2("deployment");
@@ -28355,10 +28370,9 @@ var init_runtimeConfig = __esm({
       const reference = deployment.strategies.find(
         (strategy) => strategy.strategyName === strategyName
       );
-      if (!reference?.releaseVersion) {
-        throw new Error(`${strategyName} is not a versioned deployment reference`);
-      }
-      const previousState = reference.controlState ?? "active";
+      if (!reference)
+        throw new Error(`${strategyName} is not bound to ${deploymentId}`);
+      const previousState = reference.controlState;
       const updated = await (0, import_runtimeDeployments2.saveRuntimeDeployment)(userName2, {
         ...deployment,
         strategies: deployment.strategies.map(
@@ -28388,12 +28402,6 @@ var init_runtimeConfig = __esm({
       const release = (await (0, import_runtimeStrategyReleases.listRuntimeStrategyReleases)(userName2, strategyName)).find((candidate) => candidate.releaseVersion === releaseVersion);
       if (!release)
         throw new Error(`Release not found: ${strategyName} v${releaseVersion}`);
-      const backupPath = await writeMigrationBackup({
-        userName: userName2,
-        capturedAt: Date.now(),
-        deployment,
-        reason: "rollback"
-      });
       const updated = await (0, import_runtimeDeployments2.saveRuntimeDeployment)(userName2, {
         ...deployment,
         strategies: deployment.strategies.map(
@@ -28404,7 +28412,7 @@ var init_runtimeConfig = __esm({
           } : strategy
         )
       });
-      console.log(JSON.stringify({ backupPath, deployment: updated }, null, 2));
+      console.log(JSON.stringify({ deployment: updated }, null, 2));
     };
     verify = async () => {
       const deployments = await (0, import_runtimeDeployments2.listRuntimeDeployments)(userName2);
@@ -28415,8 +28423,7 @@ var init_runtimeConfig = __esm({
           const strategies = await (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({
             userName: userName2,
             projectRoot: projectRoot12,
-            deployment,
-            connectorName: deployment.connectorName
+            deployment
           });
           results2.push({
             deploymentId: deployment.id,
@@ -28448,16 +28455,15 @@ var init_runtimeConfig = __esm({
       console.log(JSON.stringify({ userName: userName2, deployments, releases }, null, 2));
     };
     runtimeConfig = async () => {
-      if (action === "bootstrap") return bootstrap();
-      if (action === "migrate") return migrate();
-      if (action === "publish-draft") return publishDraft();
+      if (action === "provision") return provision();
+      if (action === "rollout") return rollout();
       if (action === "verify") return verify();
       if (action === "pause") return updateControlState("entries_paused");
       if (action === "resume") return updateControlState("active");
       if (action === "rollback") return rollback();
       if (action === "inspect") return inspect();
       throw new Error(
-        "Usage: tradejs runtime-config inspect|verify|bootstrap|migrate|publish-draft|pause|resume|rollback"
+        `Usage: tradejs runtime-config ${RUNTIME_CONFIG_ACTIONS.join("|")}`
       );
     };
     main37 = runtimeConfig;
@@ -32057,18 +32063,15 @@ var init_tickerEvaluator = __esm({
       for (const runtimeStrategy of runtimeStrategies) {
         const {
           strategyName,
-          configId,
           releaseVersion,
           controlState,
           strategyPackageVersion,
           runtimePackageVersion,
           strategyCreator,
           sourceStrategyConfig,
-          strategyConfig,
-          strategyResults
+          strategyConfig
         } = runtimeStrategy;
-        const runtimeIdentity = releaseVersion ? `v${releaseVersion}` : configId ?? "config";
-        const symbolResultConfig = strategyResults?.[symbol]?.config ?? null;
+        const runtimeIdentity = `v${releaseVersion}`;
         const runtimeConfig2 = buildRuntimeModeStrategyConfig({
           strategyConfig,
           env: "CRON",
@@ -32081,7 +32084,7 @@ var init_tickerEvaluator = __esm({
           releaseVersion,
           strategyPackageVersion,
           runtimePackageVersion,
-          config: { configId, strategyConfig, symbolResultConfig },
+          config: { strategyConfig },
           runContext: {
             connectorName: connectorName.toLowerCase(),
             interval: String(interval4),
@@ -32109,7 +32112,7 @@ var init_tickerEvaluator = __esm({
           evaluation = await lifecycle.evaluate({
             key: lifecycleKey,
             timestamp: lastCandle.timestamp,
-            config: { runtimeConfig: runtimeConfig2, sourceStrategyConfig, symbolResultConfig },
+            config: { runtimeConfig: runtimeConfig2, sourceStrategyConfig },
             btcBinanceData,
             btcCoinbaseData,
             onRuntimeClose: (event) => runtimeCloseNotifications.push(event),
@@ -32120,13 +32123,12 @@ var init_tickerEvaluator = __esm({
             }) => strategyCreator({
               userName: userName3,
               connectorName,
-              runtimeConfigId: configId,
+              runtimeConfigId: runtimeIdentity,
               runtimeReleaseVersion: releaseVersion,
               entriesPaused: controlState === "entries_paused",
               runtimeLineage,
               runtimeConfigSnapshot: {
-                userConfig: sourceStrategyConfig,
-                symbolResultConfig
+                userConfig: sourceStrategyConfig
               },
               connector,
               symbol,
@@ -32176,12 +32178,12 @@ var init_tickerEvaluator = __esm({
               strategyName,
               symbol,
               timestamp: lastCandle.timestamp,
-              runtimeConfigId: configId,
+              runtimeConfigId: runtimeIdentity,
               runtimeReleaseVersion: releaseVersion
             }),
             userName: userName3,
             strategy: strategyName,
-            runtimeConfigId: configId,
+            runtimeConfigId: runtimeIdentity,
             runtimeReleaseVersion: releaseVersion,
             runtimeLineage,
             symbol,
@@ -32199,12 +32201,9 @@ var init_tickerEvaluator = __esm({
           continue;
         }
         if (stats) stats.signals += 1;
-        signal.runtimeConfigId = configId;
+        signal.runtimeConfigId = runtimeIdentity;
         signal.runtimeReleaseVersion = releaseVersion;
         signal.runtimeLineage = runtimeLineage;
-        if (configId && configId !== "config" && !signal.signalId.endsWith(`:${configId}`)) {
-          signal.signalId = `${signal.signalId}:${configId}`;
-        }
         if (releaseVersion && !signal.signalId.endsWith(`:v${releaseVersion}`)) {
           signal.signalId = `${signal.signalId}:v${releaseVersion}`;
         }
@@ -32224,12 +32223,12 @@ var init_tickerEvaluator = __esm({
             strategyName,
             symbol,
             timestamp: lastCandle.timestamp,
-            runtimeConfigId: configId,
+            runtimeConfigId: runtimeIdentity,
             runtimeReleaseVersion: releaseVersion
           }),
           userName: userName3,
           strategy: strategyName,
-          runtimeConfigId: configId,
+          runtimeConfigId: runtimeIdentity,
           runtimeReleaseVersion: releaseVersion,
           runtimeLineage,
           symbol,
@@ -32338,15 +32337,12 @@ var init_runner = __esm({
       ].join("\n");
       const resolveSignalsConnectorName = async (value) => {
         const connectorName = await (0, import_connectors16.resolveConnectorName)(value, projectRoot15);
-        if (connectorName) {
-          return connectorName;
+        if (!connectorName) {
+          throw new Error(
+            `Unknown runtime connector: ${String(value || "").trim() || String(value)}`
+          );
         }
-        import_logger10.logger.warn(
-          'Unknown connector "%s". Fallback to %s.',
-          String(value || "").trim() || String(value),
-          import_connectors16.DEFAULT_CONNECTOR_NAME
-        );
-        return import_connectors16.DEFAULT_CONNECTOR_NAME;
+        return connectorName;
       };
       const createSignalsSession2 = async (lifecycle, scope = {}) => {
         const deployment = config2.deploymentId ? await (0, import_runtimeDeployments3.getRuntimeDeployment)(config2.userName, config2.deploymentId) : null;
@@ -32357,25 +32353,15 @@ var init_runner = __esm({
           throw new Error(`Runtime deployment is disabled: ${deployment.id}`);
         }
         const requestedRuntimeInterval = scope.interval ?? interval4;
-        const versionedDeployment = Boolean(
-          deployment?.strategies.some(
-            (strategy) => strategy.releaseVersion != null
-          )
-        );
-        const runtimeInterval = versionedDeployment ? requestedRuntimeInterval : deployment?.interval ?? requestedRuntimeInterval;
+        const runtimeInterval = requestedRuntimeInterval;
         const runtimeIntervalMs = Number(runtimeInterval) * 6e4;
         if (!Number.isFinite(runtimeIntervalMs) || runtimeIntervalMs <= 0) {
           throw new Error(`Invalid runtime timeframe: ${runtimeInterval}`);
         }
-        if (deployment && !versionedDeployment && String(deployment.interval) !== String(requestedRuntimeInterval)) {
-          throw new Error(
-            `Deployment ${deployment.id} requires timeframe ${deployment.interval}; received ${requestedRuntimeInterval}`
-          );
-        }
         const connectorName = await resolveSignalsConnectorName(
           deployment?.connectorName ?? scope.connectorName ?? config2.connectorName
         );
-        const universe = versionedDeployment ? scope.universe ?? config2.universe : deployment?.universe ?? scope.universe ?? config2.universe;
+        const universe = scope.universe ?? config2.universe;
         const requestedAccountId = deployment?.accountId ?? scope.accountId ?? config2.accountId;
         const connectorFactory = await (0, import_connectors16.getConnectorCreatorByName)(
           connectorName,
@@ -32587,7 +32573,6 @@ var init_runner = __esm({
             userName: config2.userName,
             projectRoot: projectRoot15,
             deployment,
-            connectorName,
             universe,
             accountId,
             interval: interval5
@@ -32595,8 +32580,8 @@ var init_runner = __esm({
           if (!runtimeStrategies.length) {
             lifecycle.clear();
             import_logger10.logger.warn(
-              "No strategy configs found by users:%s:strategies:*:config",
-              config2.userName
+              "No strategy releases are bound to deployment %s",
+              deployment?.id
             );
             return;
           }
@@ -32604,7 +32589,7 @@ var init_runner = __esm({
             new Set(
               tickers.flatMap(
                 (symbol) => runtimeStrategies.map(
-                  ({ strategyName, configId, releaseVersion }) => buildSignalsStrategyLifecycleKey({
+                  ({ strategyName, releaseVersion }) => buildSignalsStrategyLifecycleKey({
                     connectorName,
                     universe: sessionUniverse,
                     accountId,
@@ -32612,7 +32597,7 @@ var init_runner = __esm({
                     symbol,
                     interval: interval5,
                     strategyName,
-                    configId: releaseVersion ? `v${releaseVersion}` : configId
+                    configId: `v${releaseVersion}`
                   })
                 )
               )
@@ -32801,11 +32786,10 @@ var init_runner = __esm({
         const configuredStrategies = await (0, import_runtimeStrategies2.loadResolvedRuntimeStrategies)({
           userName: config2.userName,
           projectRoot: projectRoot15,
-          deployment,
-          connectorName: config2.connectorName
+          deployment
         });
         const connectorName = await resolveSignalsConnectorName(
-          deployment?.connectorName ?? config2.connectorName
+          deployment.connectorName
         );
         const scopes = /* @__PURE__ */ new Map();
         for (const strategy of configuredStrategies) {
@@ -32824,13 +32808,18 @@ var init_runner = __esm({
         }
         return scopes;
       };
-      const hasExplicitSignalsScope = () => Boolean(config2.hasExplicitScope);
       const signalsConfiguredScopesOnce2 = async () => {
-        if (config2.updateOnly || config2.showTickersList || hasExplicitSignalsScope()) {
+        if (config2.updateOnly || config2.showTickersList) {
           return signals2();
         }
-        const configuredDeployment = config2.deploymentId ? await (0, import_runtimeDeployments3.getRuntimeDeployment)(config2.userName, config2.deploymentId) : null;
-        if (config2.deploymentId && !configuredDeployment) {
+        if (!config2.deploymentId) {
+          throw new Error("Runtime deployment id is required");
+        }
+        const configuredDeployment = await (0, import_runtimeDeployments3.getRuntimeDeployment)(
+          config2.userName,
+          config2.deploymentId
+        );
+        if (!configuredDeployment) {
           throw new Error(`Runtime deployment not found: ${config2.deploymentId}`);
         }
         const scopes = await loadConfiguredSignalsScopes(configuredDeployment);
@@ -32855,8 +32844,14 @@ var init_runner = __esm({
           );
         }
         const abortController = new AbortController();
-        const daemonDeployment = config2.deploymentId ? await (0, import_runtimeDeployments3.getRuntimeDeployment)(config2.userName, config2.deploymentId) : null;
-        if (config2.deploymentId && !daemonDeployment) {
+        if (!config2.deploymentId) {
+          throw new Error("Runtime deployment id is required");
+        }
+        const daemonDeployment = await (0, import_runtimeDeployments3.getRuntimeDeployment)(
+          config2.userName,
+          config2.deploymentId
+        );
+        if (!daemonDeployment) {
           throw new Error(`Runtime deployment not found: ${config2.deploymentId}`);
         }
         const sessions = /* @__PURE__ */ new Map();
@@ -32869,10 +32864,7 @@ var init_runner = __esm({
         const stopOnSigterm = () => stop("SIGTERM");
         process.once("SIGINT", stopOnSigint);
         process.once("SIGTERM", stopOnSigterm);
-        import_logger10.logger.info(
-          "signals daemon started (config-driven scopes, fallback interval=%s)",
-          interval4
-        );
+        import_logger10.logger.info("signals daemon started (deployment-driven scopes)");
         try {
           await runSignalsDaemon({
             intervalMs: 6e4,
@@ -32985,7 +32977,7 @@ __export(signals_exports, {
   signalsConfiguredScopesOnce: () => signalsConfiguredScopesOnce,
   signalsDaemon: () => signalsDaemon
 });
-var import_config12, import_args31, flags29, hasExplicitScope, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main41;
+var import_config12, import_args31, flags29, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main41;
 var init_signals = __esm({
   "src/scripts/signals.ts"() {
     "use strict";
@@ -33029,11 +33021,6 @@ var init_signals = __esm({
     import_args31.default.option(["A", "account"], "Trading account id");
     import_args31.default.option(["D", "deployment"], "Runtime deployment id");
     flags29 = import_args31.default.parse(process.argv);
-    hasExplicitScope = process.argv.some(
-      (argument) => ["-f", "--timeframe", "-V", "--universe", "-A", "--account"].some(
-        (option2) => argument === option2 || argument.startsWith(`${option2}=`)
-      )
-    );
     config = {
       projectRoot: String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
       userName: String(flags29.user || "root"),
@@ -33055,8 +33042,7 @@ var init_signals = __esm({
       showSkipStats: Boolean(flags29.showSkipStats),
       parallel: flags29.parallel,
       watch: Boolean(flags29.watch),
-      settleDelayMs: flags29.settleDelayMs,
-      hasExplicitScope
+      settleDelayMs: flags29.settleDelayMs
     };
     runner = createSignalsRunner(config);
     createSignalsSession = runner.createSession;
@@ -37134,7 +37120,7 @@ var init_signalsSummary = __esm({
       for (const trade of trades) {
         const deployment = trade.deploymentId ? deploymentById.get(trade.deploymentId) : void 0;
         const connectorName = deployment?.connectorName ?? fallbackConnectorName;
-        const universe = trade.universe ?? deployment?.universe ?? "crypto";
+        const universe = trade.universe ?? "crypto";
         const accountId = trade.accountId ?? deployment?.accountId;
         const deploymentId = trade.deploymentId;
         const scopeKey = JSON.stringify([