@tradejs/cli 3.1.8-beta.207 → 3.1.8-beta.212

package/dist/cli.js

@@ -2173,9 +2173,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path37) => (Array.isArray(path37) ? path37 : path37.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path37) => {
-      const segments = normalizeFeaturePath(path37);
+    normalizeFeaturePath = (path36) => (Array.isArray(path36) ? path36 : path36.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path36) => {
+      const segments = normalizeFeaturePath(path36);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2349,8 +2349,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path37) => {
-      const segments = (Array.isArray(path37) ? path37 : path37.split(".")).filter(
+    classifyAiPocketFeaturePath = (path36) => {
+      const segments = (Array.isArray(path36) ? path36 : path36.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -10681,27 +10681,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path37) => {
-      if (path37.includes("global-metrics")) return "global";
-      if (path37.includes("cryptocurrency/quotes")) return "reference";
-      if (path37.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path37.includes("fear-and-greed")) return "fearGreed";
-      if (path37.includes("cmc100")) return "cmc100";
-      if (path37.includes("cmc20")) return "cmc20";
-      return path37;
-    };
-    recordCoinMarketCapFetchStats = (stats, path37, creditCount) => {
+    getCoinMarketCapPathLabel = (path36) => {
+      if (path36.includes("global-metrics")) return "global";
+      if (path36.includes("cryptocurrency/quotes")) return "reference";
+      if (path36.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path36.includes("fear-and-greed")) return "fearGreed";
+      if (path36.includes("cmc100")) return "cmc100";
+      if (path36.includes("cmc20")) return "cmc20";
+      return path36;
+    };
+    recordCoinMarketCapFetchStats = (stats, path36, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path37) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path36) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path37, existing);
+      stats.byPath.set(path36, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path37, item]) => `${getCoinMarketCapPathLabel(path37)}=${item.requests}req/${item.credits}cr`
+        ([path36, item]) => `${getCoinMarketCapPathLabel(path36)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -13460,7 +13460,7 @@ var init_workerPool = __esm({
 });
 
 // src/lib/backtest/runnerCore.ts
-var import_fs, import_path5, import_chalk14, import_backtest, import_constants8, import_time3, import_backtestArtifacts, import_redis6, import_runtimeDeployments, import_types4, formatWindowDays, getResultAmount, getResultNetProfit2, recordError, insertTopResult, updateTopResults, updateBestTickerResult, chunkTestSuiteBySymbol, mergePersistedTestSummaries, getLogsById, resolveResultArtifacts, setTestData, persistTestSummariesIndex, validateBacktestRuntimeDeployment, prepareRunEnvironment2, buildPreparedTestSuite, trackTopResult, buildRunIntroLines, resolveTesterWorker, executeTestSuite, printRunOutro;
+var import_fs, import_path5, import_chalk14, import_backtest, import_constants8, import_time3, import_backtestArtifacts, import_redis6, import_runtimeStrategies, import_types4, formatWindowDays, getResultAmount, getResultNetProfit2, recordError, insertTopResult, updateTopResults, updateBestTickerResult, chunkTestSuiteBySymbol, mergePersistedTestSummaries, getLogsById, resolveResultArtifacts, setTestData, persistTestSummariesIndex, validateBacktestRuntimeDeployment, prepareRunEnvironment2, buildPreparedTestSuite, trackTopResult, buildRunIntroLines, resolveTesterWorker, executeTestSuite, printRunOutro;
 var init_runnerCore = __esm({
   "src/lib/backtest/runnerCore.ts"() {
     "use strict";
@@ -13472,7 +13472,7 @@ var init_runnerCore = __esm({
     import_time3 = require("@tradejs/core/time");
     import_backtestArtifacts = require("@tradejs/infra/backtestArtifacts");
     import_redis6 = require("@tradejs/infra/redis");
-    import_runtimeDeployments = require("@tradejs/infra/runtimeDeployments");
+    import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
     import_types4 = require("@tradejs/types");
     init_runFormatting();
     init_marketContextPrepare();
@@ -13680,7 +13680,11 @@ var init_runnerCore = __esm({
     };
     prepareRunEnvironment2 = async () => {
       const deployment = validateBacktestRuntimeDeployment({
-        deployment: flags5.deployment ? await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, String(flags5.deployment)) : null,
+        deployment: flags5.deployment ? await (0, import_runtimeStrategies.getRuntimeDeployment)({
+          userName,
+          projectRoot: projectRoot3,
+          deploymentId: String(flags5.deployment)
+        }) : null,
         deploymentId: typeof flags5.deployment === "string" ? flags5.deployment : void 0
       });
       const preparedRun = await prepareRunEnvironment({
@@ -23956,7 +23960,7 @@ var init_runtimeSignalsStorage = __esm({
       strategy: signal.strategy,
       timestamp: signal.timestamp,
       ...signal.runtimeConfigId && signal.runtimeConfigId !== "config" ? { runtimeConfigId: signal.runtimeConfigId } : {},
-      ...signal.runtimeReleaseVersion ? { runtimeReleaseVersion: signal.runtimeReleaseVersion } : {}
+      ...signal.runtimeVersion ? { runtimeVersion: signal.runtimeVersion } : {}
     });
     shouldStoreRuntimeSignalDiagnostics = (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed";
     toStoredRuntimeSignal = (signal) => {
@@ -25225,20 +25229,20 @@ async function buildRuntimeLineage({
   projectRoot: projectRoot15,
   strategyName,
   compositionId,
-  releaseVersion,
+  version,
   strategyPackageVersion,
   runtimePackageVersion,
   config: config2,
   runContext,
   env = process.env
 }) {
-  if (releaseVersion != null) {
-    if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
-      throw new Error(`Invalid runtime releaseVersion: ${releaseVersion}`);
+  if (version != null) {
+    if (!Number.isSafeInteger(version) || version <= 0) {
+      throw new Error(`Invalid runtime strategy version: ${version}`);
     }
     return {
       schemaVersion: 2,
-      releaseVersion,
+      version,
       strategyPackageVersion,
       runtimePackageVersion,
       maxLossValue: resolveRuntimeMaxLossValue(config2)
@@ -25465,7 +25469,7 @@ var init_runtimeLineage = __esm({
       gateFingerprintCache.set(cacheKey, result);
       return result;
     };
-    runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.releaseVersion].join(":") : [
+    runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.version].join(":") : [
       lineage.schemaVersion,
       lineage.compositionId ?? "unbound-composition",
       lineage.gitSha ?? "unknown",
@@ -26881,8 +26885,8 @@ var init_strategyRelease = __esm({
         return false;
       }
     };
-    hasExactRuntimeTarget = (target) => Boolean(
-      target?.userName.trim() && target.deploymentId.trim() && target.accountId.trim() && target.strategyConfigName.trim()
+    hasExactRuntimeTarget = (target, strategyName) => Boolean(
+      target?.userName.trim() && target.deploymentId.trim() && target.accountId.trim() && target.strategyName.trim() === strategyName.trim() && Number.isSafeInteger(target.version) && target.version > 0
     );
     deriveStrategyReleaseResearchDecision = async (input) => {
       const blockers = [];
@@ -26967,13 +26971,14 @@ var init_strategyRelease = __esm({
           targetDirection: input.recentFailure?.direction ?? null,
           maxLossValue: 1,
           requiresRuntimeBinding: !hasExactRuntimeTarget(
-            input.forwardTest.runtimeTarget
+            input.forwardTest.runtimeTarget,
+            input.strategy
           ),
           blockers: ["FORWARD_NOT_AUTHORIZED"],
           summary: "The candidate is ready for a separately authorized micro-forward test at MAX_LOSS_VALUE=1."
         };
       }
-      if (!hasExactRuntimeTarget(input.forwardTest.runtimeTarget)) {
+      if (!hasExactRuntimeTarget(input.forwardTest.runtimeTarget, input.strategy)) {
         return {
           strategy: input.strategy,
           action: "MICRO_FORWARD_READY",
@@ -26982,7 +26987,7 @@ var init_strategyRelease = __esm({
           maxLossValue: 1,
           requiresRuntimeBinding: true,
           blockers: [],
-          summary: "The portable micro-forward handoff is ready. Bind it on the runtime server to that server's deployment/account ids and verify canonical composition fingerprints there."
+          summary: "The portable micro-forward handoff is ready. Commit its deployment, account binding, complete config, and explicit strategy version in TradeJS-Project."
         };
       }
       return {
@@ -28082,45 +28087,32 @@ var init_runtimeScorecard2 = __esm({
   }
 });
 
-// src/scripts/runtimeConfig.ts
-var runtimeConfig_exports = {};
-__export(runtimeConfig_exports, {
-  RUNTIME_CONFIG_ACTIONS: () => RUNTIME_CONFIG_ACTIONS,
-  buildProvisionedRuntimeDeployment: () => buildProvisionedRuntimeDeployment,
-  isEquivalentRuntimeStrategyRelease: () => isEquivalentRuntimeStrategyRelease,
+// src/scripts/runtimeControl.ts
+var runtimeControl_exports = {};
+__export(runtimeControl_exports, {
+  RUNTIME_CONTROL_ACTIONS: () => RUNTIME_CONTROL_ACTIONS,
   main: () => main37,
-  pointRuntimeDeploymentAtRelease: () => pointRuntimeDeploymentAtRelease,
-  resolveProvisionConnectorName: () => resolveProvisionConnectorName,
-  runtimeConfig: () => runtimeConfig
+  runtimeControl: () => runtimeControl
 });
-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, resolveProvisionConnectorName, requireRuntimePackageIdentity, toReleaseConfig, publish, buildProvisionedRuntimeDeployment, isEquivalentRuntimeStrategyRelease, pointRuntimeDeploymentAtRelease, provision, rollout, updateControlState, rollback, verify, inspect, runtimeConfig, main37;
-var init_runtimeConfig = __esm({
-  "src/scripts/runtimeConfig.ts"() {
+var import_config9, import_runtimeControls, import_runtimeStrategies2, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot12, userName2, verify, inspect, updateControlState, runtimeControl, main37;
+var init_runtimeControl = __esm({
+  "src/scripts/runtimeControl.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_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
-    import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
-    import_strategies11 = require("@tradejs/node/strategies");
+    import_runtimeControls = require("@tradejs/infra/runtimeControls");
+    import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
     argv = process.argv.slice(2);
-    RUNTIME_CONFIG_ACTIONS = [
+    RUNTIME_CONTROL_ACTIONS = [
       "inspect",
       "verify",
-      "provision",
-      "rollout",
       "pause",
-      "resume",
-      "rollback"
+      "resume"
     ];
     action = argv[0] ?? "inspect";
     option = (name) => {
       const index = argv.indexOf(`--${name}`);
       return index >= 0 ? argv[index + 1] : void 0;
     };
-    hasFlag = (name) => argv.includes(`--${name}`);
     required2 = (name) => {
       const value = String(option(name) ?? "").trim();
       if (!value) throw new Error(`--${name} is required`);
@@ -28128,319 +28120,34 @@ var init_runtimeConfig = __esm({
     };
     projectRoot12 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     userName2 = String(option("user") ?? process.env.USER_NAME ?? "root");
-    OPERATIONAL_CONFIG_KEYS = [
-      "ACCOUNT_ID",
-      "AI_REPLAY_ANALYSES",
-      "DEPLOYMENT_ID",
-      "ENABLE",
-      "ENV",
-      "MAKE_ORDERS",
-      "RECORD_RUNTIME_TRADES"
-    ];
-    resolveProvisionConnectorName = (value) => {
-      const connectorName = String(value ?? "").trim();
-      if (!connectorName) throw new Error("--connector is required");
-      return connectorName;
-    };
-    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;
-    };
-    publish = async ({
-      strategyName,
-      sourceConfig
-    }) => {
-      const config2 = await toReleaseConfig(strategyName, sourceConfig);
-      const metadata = await (0, import_runtimeStrategies.getRuntimeStrategyPackageMetadata)({
-        strategyName,
-        projectRoot: projectRoot12
-      });
-      const packageIdentity = requireRuntimePackageIdentity(strategyName, metadata);
-      return (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
-        userName: userName2,
-        strategyName,
-        config: config2,
-        ...packageIdentity,
-        createdBy: `cli:${userName2}`
-      });
-    };
-    buildProvisionedRuntimeDeployment = ({
-      deploymentId,
-      label,
-      connectorName,
-      provider,
-      accountId,
-      strategyName,
-      releaseVersion
-    }) => ({
-      id: deploymentId,
-      label,
-      connectorName,
-      provider,
-      accountId,
-      enabled: true,
-      strategies: [
-        {
-          strategyName,
-          releaseVersion,
-          controlState: "entries_paused"
-        }
-      ]
-    });
-    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");
-      const connectorName = resolveProvisionConnectorName(option("connector"));
-      const provider = option("provider") ?? connectorName;
-      const label = option("label") ?? deploymentId;
-      const configFile = import_node_path23.default.resolve(projectRoot12, required2("file"));
-      const sourceConfig = JSON.parse(
-        await (0, import_promises28.readFile)(configFile, "utf8")
-      );
-      const existingDeployment = await (0, import_runtimeDeployments2.getRuntimeDeployment)(userName2, deploymentId);
-      if (existingDeployment) {
-        throw new Error(
-          `Deployment already exists: ${deploymentId}; publish a release and switch its pointer instead`
-        );
-      }
-      const releaseConfig = await toReleaseConfig(strategyName, sourceConfig);
-      const previewDeployment = buildProvisionedRuntimeDeployment({
-        deploymentId,
-        label,
-        connectorName,
-        provider,
-        accountId,
-        strategyName,
-        releaseVersion: 1
-      });
-      if (!hasFlag("write")) {
-        console.log(
-          JSON.stringify(
-            {
-              dryRun: true,
-              releaseConfig,
-              deployment: {
-                ...previewDeployment,
-                strategies: previewDeployment.strategies.map((strategy) => ({
-                  ...strategy,
-                  releaseVersion: "<allocated on write>"
-                }))
-              }
-            },
-            null,
-            2
-          )
-        );
-        return;
-      }
-      const release = await publish({ strategyName, sourceConfig });
-      const deployment = await (0, import_runtimeDeployments2.saveRuntimeDeployment)(
-        userName2,
-        buildProvisionedRuntimeDeployment({
-          deploymentId,
-          label,
-          connectorName,
-          provider,
-          accountId,
-          strategyName,
-          releaseVersion: release.releaseVersion
-        })
-      );
-      console.log(
-        JSON.stringify({ provisioned: true, release, deployment }, null, 2)
-      );
-    };
-    rollout = async () => {
-      const strategyName = required2("strategy");
-      const deploymentId = required2("deployment");
-      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 (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
-      const reference = deployment.strategies.find(
-        (strategy) => strategy.strategyName === strategyName
-      );
-      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 = {
-        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;
-      }
-      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,
-        strategyName,
-        config: config2,
-        ...packageIdentity,
-        createdBy: `cli:${userName2}`
-      });
-      const updatedDeployment = pointRuntimeDeploymentAtRelease({
-        deployment,
-        strategyName,
-        releaseVersion: release.releaseVersion
-      });
-      await (0, import_runtimeDeployments2.saveRuntimeDeployment)(userName2, updatedDeployment);
-      console.log(
-        JSON.stringify(
-          {
-            rolledOut: true,
-            release,
-            deployment: updatedDeployment
-          },
-          null,
-          2
-        )
-      );
-    };
-    updateControlState = async (nextState) => {
-      const strategyName = required2("strategy");
-      const deploymentId = required2("deployment");
-      const deployment = await (0, import_runtimeDeployments2.getRuntimeDeployment)(userName2, deploymentId);
-      if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
-      const reference = deployment.strategies.find(
-        (strategy) => strategy.strategyName === strategyName
-      );
-      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(
-          (strategy) => strategy.strategyName === strategyName ? { ...strategy, controlState: nextState } : strategy
-        )
-      });
-      const event = previousState === nextState ? null : await (0, import_runtimeStrategyReleases.recordRuntimeStrategyControlEvent)({
-        userName: userName2,
-        deploymentId,
-        strategyName,
-        releaseVersion: reference.releaseVersion,
-        previousState,
-        nextState,
-        createdBy: `cli:${userName2}`
-      });
-      console.log(JSON.stringify({ deployment: updated, event }, null, 2));
-    };
-    rollback = async () => {
-      const strategyName = required2("strategy");
-      const deploymentId = required2("deployment");
-      const releaseVersion = Number(required2("release"));
-      if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
-        throw new Error("--release must be a positive integer");
-      }
-      const deployment = await (0, import_runtimeDeployments2.getRuntimeDeployment)(userName2, deploymentId);
-      if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
-      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 updated = await (0, import_runtimeDeployments2.saveRuntimeDeployment)(userName2, {
-        ...deployment,
-        strategies: deployment.strategies.map(
-          (strategy) => strategy.strategyName === strategyName ? {
-            strategyName,
-            releaseVersion,
-            controlState: "entries_paused"
-          } : strategy
-        )
-      });
-      console.log(JSON.stringify({ deployment: updated }, null, 2));
-    };
     verify = async () => {
-      const deployments = await (0, import_runtimeDeployments2.listRuntimeDeployments)(userName2);
-      const selected = option("deployment") ? deployments.filter((deployment) => deployment.id === option("deployment")) : deployments;
+      const deployments = await (0, import_runtimeStrategies2.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 });
+      const requestedDeployment = option("deployment");
+      const selected = requestedDeployment ? deployments.filter((deployment) => deployment.id === requestedDeployment) : deployments;
+      if (requestedDeployment && !selected.length) {
+        throw new Error(`Runtime deployment not found: ${requestedDeployment}`);
+      }
       const results2 = [];
       for (const deployment of selected) {
         try {
-          const strategies = await (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({
+          const strategies = await (0, import_runtimeStrategies2.loadResolvedRuntimeStrategies)({
             userName: userName2,
             projectRoot: projectRoot12,
-            deployment
+            deploymentId: deployment.id
           });
           results2.push({
             deploymentId: deployment.id,
             ok: true,
             strategies: strategies.map((strategy) => ({
               strategyName: strategy.strategyName,
-              releaseVersion: strategy.releaseVersion,
+              version: strategy.version,
               controlState: strategy.controlState,
               interval: strategy.interval,
               universe: strategy.universe,
-              accountId: strategy.accountId
+              accountId: strategy.accountId,
+              strategyPackage: strategy.strategyPackage,
+              strategyPackageVersion: strategy.strategyPackageVersion,
+              runtimePackageVersion: strategy.runtimePackageVersion
             }))
           });
         } catch (error) {
@@ -28455,24 +28162,86 @@ var init_runtimeConfig = __esm({
       if (results2.some((result) => !result.ok)) process.exitCode = 1;
     };
     inspect = async () => {
-      const strategyName = option("strategy");
-      const deployments = await (0, import_runtimeDeployments2.listRuntimeDeployments)(userName2);
-      const releases = strategyName ? await (0, import_runtimeStrategyReleases.listRuntimeStrategyReleases)(userName2, strategyName) : void 0;
-      console.log(JSON.stringify({ userName: userName2, deployments, releases }, null, 2));
-    };
-    runtimeConfig = async () => {
-      if (action === "provision") return provision();
-      if (action === "rollout") return rollout();
+      const requestedDeployment = option("deployment");
+      const requestedStrategy = option("strategy");
+      const deployments = (await (0, import_runtimeStrategies2.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 })).filter(
+        (deployment) => !requestedDeployment || deployment.id === requestedDeployment
+      ).map((deployment) => ({
+        ...deployment,
+        strategies: deployment.strategies.filter(
+          (strategy) => !requestedStrategy || strategy.strategyName === requestedStrategy
+        )
+      }));
+      console.log(JSON.stringify({ userName: userName2, deployments }, null, 2));
+    };
+    updateControlState = async (nextState) => {
+      const deploymentId = required2("deployment");
+      const strategyName = required2("strategy");
+      const deployment = await (0, import_runtimeStrategies2.getRuntimeDeployment)({
+        userName: userName2,
+        projectRoot: projectRoot12,
+        deploymentId
+      });
+      if (!deployment) {
+        throw new Error(`Runtime deployment not found: ${deploymentId}`);
+      }
+      const reference = deployment.strategies.find(
+        (strategy) => strategy.strategyName === strategyName
+      );
+      if (!reference) {
+        throw new Error(`${strategyName} is not declared in ${deploymentId}`);
+      }
+      if (nextState === "active" && (!deployment.enabled || !reference.enabled)) {
+        throw new Error(
+          `${strategyName} is disabled in tradejs.config.ts and cannot be resumed manually`
+        );
+      }
+      const previousState = reference.controlState;
+      if (nextState === "entries_paused") {
+        await (0, import_runtimeControls.pauseRuntimeStrategy)({
+          userName: userName2,
+          deploymentId,
+          strategyName,
+          updatedBy: `cli:${userName2}`
+        });
+      } else {
+        await (0, import_runtimeControls.resumeRuntimeStrategy)({ userName: userName2, deploymentId, strategyName });
+      }
+      const updated = await (0, import_runtimeStrategies2.getRuntimeDeployment)({
+        userName: userName2,
+        projectRoot: projectRoot12,
+        deploymentId
+      });
+      const updatedReference = updated?.strategies.find(
+        (strategy) => strategy.strategyName === strategyName
+      );
+      const event = previousState === nextState ? null : await (0, import_runtimeControls.recordRuntimeStrategyControlEvent)({
+        userName: userName2,
+        deploymentId,
+        strategyName,
+        version: reference.version,
+        previousState,
+        nextState,
+        createdBy: `cli:${userName2}`
+      });
+      console.log(
+        JSON.stringify(
+          { deployment: updated, strategy: updatedReference, event },
+          null,
+          2
+        )
+      );
+    };
+    runtimeControl = async () => {
       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 ${RUNTIME_CONFIG_ACTIONS.join("|")}`
+        `Usage: tradejs runtime-control ${RUNTIME_CONTROL_ACTIONS.join("|")}`
       );
     };
-    main37 = runtimeConfig;
+    main37 = runtimeControl;
   }
 });
 
@@ -28482,14 +28251,14 @@ __export(strategyRelease_exports, {
   main: () => main38,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises29, import_node_fs5, import_node_readline2, import_node_path24, import_chalk42, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main38;
+var import_promises28, import_node_fs5, import_node_readline2, import_node_path23, import_chalk42, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main38;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises29 = __toESM(require("fs/promises"));
+    import_promises28 = __toESM(require("fs/promises"));
     import_node_fs5 = require("fs");
     import_node_readline2 = require("readline");
-    import_node_path24 = __toESM(require("path"));
+    import_node_path23 = __toESM(require("path"));
     import_chalk42 = __toESM(require("chalk"));
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
@@ -28502,17 +28271,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises29.default.mkdir(import_node_path24.default.dirname(filePath), { recursive: true });
-      await import_promises29.default.writeFile(
+      await import_promises28.default.mkdir(import_node_path23.default.dirname(filePath), { recursive: true });
+      await import_promises28.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises29.default.rename(temporaryPath, filePath);
+      await import_promises28.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path24.default.resolve(options.inputPath);
+      const inputPath = import_node_path23.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -28550,7 +28319,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path24.default.resolve(
+        const outputPath = import_node_path23.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -28561,22 +28330,22 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises29.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises28.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path24.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path23.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path24.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path23.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
         if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises29.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises28.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -28589,12 +28358,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path24.default.resolve(
+        const outputPath = import_node_path23.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path24.default.resolve(options.rootDir),
+          rootDir: import_node_path23.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -28611,7 +28380,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path24.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path23.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -28713,21 +28482,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path37) => {
+    readDiskUsage = (path36) => {
       try {
-        const stats = (0, import_node_fs6.statfsSync)(path37);
+        const stats = (0, import_node_fs6.statfsSync)(path36);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path37, usedPct: null };
+          return { path: path36, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path37,
+          path: path36,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path37, usedPct: null };
+        return { path: path36, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -31386,11 +31155,11 @@ var init_hooks = __esm({
 });
 
 // src/lib/signals/runtimeStrategies.ts
-var import_runtimeStrategies2;
+var import_runtimeStrategies3;
 var init_runtimeStrategies = __esm({
   "src/lib/signals/runtimeStrategies.ts"() {
     "use strict";
-    import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
   }
 });
 
@@ -31465,12 +31234,12 @@ var init_evaluations = __esm({
       symbol,
       timestamp,
       runtimeConfigId,
-      runtimeReleaseVersion
-    }) => runtimeReleaseVersion ? [strategyName, `v${runtimeReleaseVersion}`, symbol, timestamp].join(":") : runtimeConfigId && runtimeConfigId !== "config" ? [strategyName, runtimeConfigId, symbol, timestamp].join(":") : [strategyName, symbol, timestamp].join(":");
+      runtimeVersion
+    }) => runtimeVersion ? [strategyName, `v${runtimeVersion}`, symbol, timestamp].join(":") : runtimeConfigId && runtimeConfigId !== "config" ? [strategyName, runtimeConfigId, symbol, timestamp].join(":") : [strategyName, symbol, timestamp].join(":");
     buildLineageField = (scope) => [
       scope.strategy,
       scope.runtimeConfigId ?? "config",
-      scope.runtimeReleaseVersion ? `v${scope.runtimeReleaseVersion}` : "legacy",
+      scope.runtimeVersion ? `v${scope.runtimeVersion}` : "legacy",
       scope.symbol,
       runtimeLineageKey(scope.lineage)
     ].join(":");
@@ -31510,7 +31279,7 @@ var init_evaluations = __esm({
           const lineageField = buildLineageField({
             strategy: evaluation.strategy,
             runtimeConfigId: evaluation.runtimeConfigId,
-            runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
+            runtimeVersion: evaluation.runtimeVersion,
             symbol: evaluation.symbol,
             lineage: evaluation.runtimeLineage
           });
@@ -31520,7 +31289,7 @@ var init_evaluations = __esm({
             strategy: evaluation.strategy,
             symbol: evaluation.symbol,
             runtimeConfigId: evaluation.runtimeConfigId,
-            runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
+            runtimeVersion: evaluation.runtimeVersion,
             lineage: evaluation.runtimeLineage,
             firstTimestamp: Math.min(
               existing?.firstTimestamp ?? evaluation.timestamp,
@@ -31885,7 +31654,7 @@ var init_klineFeed = __esm({
       config: config2,
       interval: interval4,
       universe,
-      publish: publish2 = publishMarketKlineEvent,
+      publish = publishMarketKlineEvent,
       persist = async (rows) => {
         const intervalMinutes = Number(interval4);
         await (0, import_candles3.upsertCandles)(
@@ -31936,7 +31705,7 @@ var init_klineFeed = __esm({
         config: config2,
         onEvent: (event) => {
           if (event.interval !== interval4) return;
-          void publish2({
+          void publish({
             provider: "bybit",
             universe,
             symbol: event.symbol,
@@ -32000,11 +31769,11 @@ var init_klineFeed = __esm({
 });
 
 // src/lib/signals/tickerEvaluator.ts
-var import_strategies12, import_logger9, createSignalsTickerEvaluator;
+var import_strategies11, import_logger9, createSignalsTickerEvaluator;
 var init_tickerEvaluator = __esm({
   "src/lib/signals/tickerEvaluator.ts"() {
     "use strict";
-    import_strategies12 = require("@tradejs/node/strategies");
+    import_strategies11 = require("@tradejs/node/strategies");
     import_logger9 = require("@tradejs/infra/logger");
     init_windows();
     init_runtimeLineage();
@@ -32069,7 +31838,7 @@ var init_tickerEvaluator = __esm({
       for (const runtimeStrategy of runtimeStrategies) {
         const {
           strategyName,
-          releaseVersion,
+          version,
           controlState,
           strategyPackageVersion,
           runtimePackageVersion,
@@ -32077,8 +31846,8 @@ var init_tickerEvaluator = __esm({
           sourceStrategyConfig,
           strategyConfig
         } = runtimeStrategy;
-        const runtimeIdentity = `v${releaseVersion}`;
-        const runtimeConfig2 = buildRuntimeModeStrategyConfig({
+        const runtimeIdentity = `v${version}`;
+        const runtimeConfig = buildRuntimeModeStrategyConfig({
           strategyConfig,
           env: "CRON",
           interval: interval4,
@@ -32087,7 +31856,7 @@ var init_tickerEvaluator = __esm({
         const runtimeLineage = await buildRuntimeLineage({
           projectRoot: projectRoot15,
           strategyName,
-          releaseVersion,
+          version,
           strategyPackageVersion,
           runtimePackageVersion,
           config: { strategyConfig },
@@ -32118,7 +31887,7 @@ var init_tickerEvaluator = __esm({
           evaluation = await lifecycle.evaluate({
             key: lifecycleKey,
             timestamp: lastCandle.timestamp,
-            config: { runtimeConfig: runtimeConfig2, sourceStrategyConfig },
+            config: { runtimeConfig, sourceStrategyConfig },
             btcBinanceData,
             btcCoinbaseData,
             onRuntimeClose: (event) => runtimeCloseNotifications.push(event),
@@ -32130,7 +31899,7 @@ var init_tickerEvaluator = __esm({
               userName: userName3,
               connectorName,
               runtimeConfigId: runtimeIdentity,
-              runtimeReleaseVersion: releaseVersion,
+              runtimeVersion: version,
               entriesPaused: controlState === "entries_paused",
               runtimeLineage,
               runtimeConfigSnapshot: {
@@ -32150,7 +31919,7 @@ var init_tickerEvaluator = __esm({
               ethData: universe === "crypto" ? previousEthData : [],
               btcBinanceData: lifecycleBtcBinanceData,
               btcCoinbaseData: lifecycleBtcCoinbaseData,
-              config: runtimeConfig2,
+              config: runtimeConfig,
               ...persistStrategyState ? { sharedStrategyStateKey: lifecycleKey } : {},
               onRuntimeClose
             }),
@@ -32185,12 +31954,12 @@ var init_tickerEvaluator = __esm({
               symbol,
               timestamp: lastCandle.timestamp,
               runtimeConfigId: runtimeIdentity,
-              runtimeReleaseVersion: releaseVersion
+              runtimeVersion: version
             }),
             userName: userName3,
             strategy: strategyName,
             runtimeConfigId: runtimeIdentity,
-            runtimeReleaseVersion: releaseVersion,
+            runtimeVersion: version,
             runtimeLineage,
             symbol,
             interval: interval4,
@@ -32198,7 +31967,7 @@ var init_tickerEvaluator = __esm({
             assetClass: instrument?.assetClass,
             accountId,
             deploymentId,
-            policyProfileId: runtimeConfig2.POLICY_PROFILE_ID,
+            policyProfileId: runtimeConfig.POLICY_PROFILE_ID,
             timestamp: lastCandle.timestamp,
             evaluatedAt: Date.now(),
             status: "skip",
@@ -32208,12 +31977,12 @@ var init_tickerEvaluator = __esm({
         }
         if (stats) stats.signals += 1;
         signal.runtimeConfigId = runtimeIdentity;
-        signal.runtimeReleaseVersion = releaseVersion;
+        signal.runtimeVersion = version;
         signal.runtimeLineage = runtimeLineage;
-        if (releaseVersion && !signal.signalId.endsWith(`:v${releaseVersion}`)) {
-          signal.signalId = `${signal.signalId}:v${releaseVersion}`;
+        if (version && !signal.signalId.endsWith(`:v${version}`)) {
+          signal.signalId = `${signal.signalId}:v${version}`;
         }
-        await (0, import_strategies12.enrichSignalWithBinanceMarketContext)({ signal, env: "CRON" });
+        await (0, import_strategies11.enrichSignalWithBinanceMarketContext)({ signal, env: "CRON" });
         if (signal.orderStatus === "skipped" && typeof signal.orderSkipReason === "string" && signal.orderSkipReason.trim()) {
           recordStrategyReason(
             strategyStats,
@@ -32230,12 +31999,12 @@ var init_tickerEvaluator = __esm({
             symbol,
             timestamp: lastCandle.timestamp,
             runtimeConfigId: runtimeIdentity,
-            runtimeReleaseVersion: releaseVersion
+            runtimeVersion: version
           }),
           userName: userName3,
           strategy: strategyName,
           runtimeConfigId: runtimeIdentity,
-          runtimeReleaseVersion: releaseVersion,
+          runtimeVersion: version,
           runtimeLineage,
           symbol,
           interval: interval4,
@@ -32268,7 +32037,7 @@ var init_configuredScopes = __esm({
   "src/lib/signals/configuredScopes.ts"() {
     "use strict";
     sorted = (values) => values ? [...values].sort() : [];
-    formatConfiguredStrategyIdentity = (strategy) => `${strategy.strategyName}@v${strategy.releaseVersion}[${strategy.controlState}]`;
+    formatConfiguredStrategyIdentity = (strategy) => `${strategy.strategyName}@v${strategy.version}[${strategy.controlState}]`;
     buildConfiguredSignalsScopes = ({
       connectorName,
       deployment,
@@ -32314,7 +32083,7 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies13, import_constants16, import_time8, import_logger10, import_runtimeDeployments3, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
+var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies12, import_constants16, import_time8, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies4, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
@@ -32323,11 +32092,12 @@ var init_runner = __esm({
     import_connectors16 = require("@tradejs/node/connectors");
     import_cli12 = require("@tradejs/node/cli");
     import_async5 = require("@tradejs/core/async");
-    import_strategies13 = require("@tradejs/core/strategies");
+    import_strategies12 = require("@tradejs/core/strategies");
     import_constants16 = require("@tradejs/core/constants");
     import_time8 = require("@tradejs/core/time");
     import_logger10 = require("@tradejs/infra/logger");
-    import_runtimeDeployments3 = require("@tradejs/infra/runtimeDeployments");
+    import_runtimeHeartbeats = require("@tradejs/infra/runtimeHeartbeats");
+    import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
     init_windows();
     init_runFormatting();
     init_hooks();
@@ -32379,7 +32149,7 @@ var init_runner = __esm({
       const createDefaultSignalsLifecycle = (runtimeInterval = interval4) => createSignalsStrategyLifecycle({
         intervalMs: Number(runtimeInterval) * 6e4,
         maxLiveBars: resolveSignalsDaemonMaxLiveBars(runtimeInterval),
-        releaseState: import_strategies13.releaseStrategyReplayCache
+        releaseState: import_strategies12.releaseStrategyReplayCache
       });
       const timeOperation3 = (label, operation) => timeOperation(
         label,
@@ -32403,13 +32173,14 @@ var init_runner = __esm({
         return connectorName;
       };
       const createSignalsSession2 = async (lifecycle, scope = {}) => {
-        const deployment = config2.deploymentId ? await (0, import_runtimeDeployments3.getRuntimeDeployment)(config2.userName, config2.deploymentId) : null;
+        const deployment = config2.deploymentId ? await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+          userName: config2.userName,
+          projectRoot: projectRoot15,
+          deploymentId: config2.deploymentId
+        }) : null;
         if (config2.deploymentId && !deployment) {
           throw new Error(`Runtime deployment not found: ${config2.deploymentId}`);
         }
-        if (deployment && !deployment.enabled) {
-          throw new Error(`Runtime deployment is disabled: ${deployment.id}`);
-        }
         const requestedRuntimeInterval = scope.interval ?? interval4;
         const runtimeInterval = requestedRuntimeInterval;
         const runtimeIntervalMs = Number(runtimeInterval) * 6e4;
@@ -32627,10 +32398,10 @@ var init_runner = __esm({
           const primaryEthByTimestamp = new Map(
             primaryEthClosedData.map((candle) => [candle.timestamp, candle])
           );
-          const runtimeStrategies = await (0, import_runtimeStrategies2.loadResolvedRuntimeStrategies)({
+          const runtimeStrategies = await (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({
             userName: config2.userName,
             projectRoot: projectRoot15,
-            deployment,
+            deploymentId: deployment?.id ?? "",
             universe,
             accountId,
             interval: interval5
@@ -32647,7 +32418,7 @@ var init_runner = __esm({
             new Set(
               tickers.flatMap(
                 (symbol) => runtimeStrategies.map(
-                  ({ strategyName, releaseVersion }) => buildSignalsStrategyLifecycleKey({
+                  ({ strategyName, version }) => buildSignalsStrategyLifecycleKey({
                     connectorName,
                     universe: sessionUniverse,
                     accountId,
@@ -32655,7 +32426,7 @@ var init_runner = __esm({
                     symbol,
                     interval: interval5,
                     strategyName,
-                    configId: `v${releaseVersion}`
+                    configId: `v${version}`
                   })
                 )
               )
@@ -32786,7 +32557,7 @@ var init_runner = __esm({
           }
           const durationMs = Date.now() - startedAt;
           if (activeSession?.deployment) {
-            await (0, import_runtimeDeployments3.saveRuntimeDeploymentHeartbeat)(config2.userName, {
+            await (0, import_runtimeHeartbeats.saveRuntimeDeploymentHeartbeat)(config2.userName, {
               deploymentId: activeSession.deployment.id,
               status: getSignalsHeartbeatStatus({
                 cycleStatus: status,
@@ -32841,10 +32612,10 @@ var init_runner = __esm({
         }
       };
       const loadConfiguredSignalsScopes = async (deployment) => {
-        const configuredStrategies = await (0, import_runtimeStrategies2.loadResolvedRuntimeStrategies)({
+        const configuredStrategies = await (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({
           userName: config2.userName,
           projectRoot: projectRoot15,
-          deployment
+          deploymentId: deployment.id
         });
         const connectorName = await resolveSignalsConnectorName(
           deployment.connectorName
@@ -32864,10 +32635,11 @@ var init_runner = __esm({
         if (!config2.deploymentId) {
           throw new Error("Runtime deployment id is required");
         }
-        const configuredDeployment = await (0, import_runtimeDeployments3.getRuntimeDeployment)(
-          config2.userName,
-          config2.deploymentId
-        );
+        const configuredDeployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+          userName: config2.userName,
+          projectRoot: projectRoot15,
+          deploymentId: config2.deploymentId
+        });
         if (!configuredDeployment) {
           throw new Error(`Runtime deployment not found: ${config2.deploymentId}`);
         }
@@ -32897,10 +32669,11 @@ var init_runner = __esm({
           throw new Error("Runtime deployment id is required");
         }
         const deploymentId = config2.deploymentId;
-        const initialDeployment = await (0, import_runtimeDeployments3.getRuntimeDeployment)(
-          config2.userName,
+        const initialDeployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+          userName: config2.userName,
+          projectRoot: projectRoot15,
           deploymentId
-        );
+        });
         if (!initialDeployment) {
           throw new Error(`Runtime deployment not found: ${deploymentId}`);
         }
@@ -32921,10 +32694,11 @@ var init_runner = __esm({
             settleDelayMs: resolveNonNegativeInteger(config2.settleDelayMs, 5e3),
             signal: abortController.signal,
             runCycle: async () => {
-              const currentDeployment = await (0, import_runtimeDeployments3.getRuntimeDeployment)(
-                config2.userName,
+              const currentDeployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+                userName: config2.userName,
+                projectRoot: projectRoot15,
                 deploymentId
-              );
+              });
               if (!currentDeployment) {
                 throw new Error(`Runtime deployment not found: ${deploymentId}`);
               }
@@ -33004,7 +32778,7 @@ var init_runner = __esm({
             await session.klineFeed?.close();
             session.lifecycle.clear();
             if (session.deployment) {
-              await (0, import_runtimeDeployments3.saveRuntimeDeploymentHeartbeat)(config2.userName, {
+              await (0, import_runtimeHeartbeats.saveRuntimeDeploymentHeartbeat)(config2.userName, {
                 deploymentId: session.deployment.id,
                 status: "stopped",
                 pid: process.pid,
@@ -33619,20 +33393,20 @@ var init_portfolioReplayConnector = __esm({
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
-var import_chalk46, import_progress12, import_backtest4, import_strategies14, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies15, 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, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
 var init_historicalSignalsReplay = __esm({
   "src/lib/replay/historicalSignalsReplay.ts"() {
     "use strict";
     import_chalk46 = __toESM(require("chalk"));
     import_progress12 = __toESM(require("progress"));
     import_backtest4 = require("@tradejs/core/backtest");
-    import_strategies14 = require("@tradejs/core/strategies");
+    import_strategies13 = require("@tradejs/core/strategies");
     import_time9 = require("@tradejs/core/time");
     import_logger11 = require("@tradejs/infra/logger");
     import_redis19 = require("@tradejs/infra/redis");
     import_connectors17 = require("@tradejs/node/connectors");
     import_cli13 = require("@tradejs/node/cli");
-    import_strategies15 = require("@tradejs/node/strategies");
+    import_strategies14 = require("@tradejs/node/strategies");
     init_cliConfig2();
     init_support();
     init_portfolioReplayConnector();
@@ -33642,7 +33416,7 @@ var init_historicalSignalsReplay = __esm({
     loadRuntimeStrategies = async (runtimeStrategies) => {
       const strategies = await Promise.all(
         runtimeStrategies.map(async ({ strategyName, strategyConfig }) => {
-          const strategyCreator = await (0, import_strategies15.getStrategyCreator)(
+          const strategyCreator = await (0, import_strategies14.getStrategyCreator)(
             strategyName,
             replayProjectRoot
           );
@@ -33989,7 +33763,7 @@ var init_historicalSignalsReplay = __esm({
               );
               if (result && typeof result !== "string") {
                 result.runtimeLineage = strategyRuntime.runtimeLineage;
-                await (0, import_strategies15.enrichSignalWithBinanceMarketContext)({
+                await (0, import_strategies14.enrichSignalWithBinanceMarketContext)({
                   signal: result,
                   env: "PARITY"
                 });
@@ -34013,8 +33787,8 @@ var init_historicalSignalsReplay = __esm({
         }
       } finally {
         for (const keyPrefix of sharedReplayKeyPrefixes) {
-          (0, import_strategies14.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-          (0, import_strategies14.releaseStrategyReplayCache)(keyPrefix);
+          (0, import_strategies13.releaseStrategyIndicatorsReplayCache)(keyPrefix);
+          (0, import_strategies13.releaseStrategyReplayCache)(keyPrefix);
         }
       }
       const artifacts = replayConnector.getReplayArtifacts();
@@ -35233,12 +35007,12 @@ var init_runtimeParityDetails = __esm({
 });
 
 // src/lib/replay/runtimeEvidenceSource.ts
-var import_promises30, import_node_path25, asRecord7, asFiniteNumber, unwrapRows2, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
+var import_promises29, import_node_path24, asRecord7, asFiniteNumber, unwrapRows2, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
 var init_runtimeEvidenceSource = __esm({
   "src/lib/replay/runtimeEvidenceSource.ts"() {
     "use strict";
-    import_promises30 = __toESM(require("fs/promises"));
-    import_node_path25 = __toESM(require("path"));
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path24 = __toESM(require("path"));
     init_runtimeLineage();
     asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -35255,7 +35029,7 @@ var init_runtimeEvidenceSource = __esm({
         strategy,
         symbol,
         runtimeConfigId,
-        runtimeReleaseVersion,
+        runtimeVersion,
         timestamp,
         lineage
       }) => {
@@ -35268,7 +35042,7 @@ var init_runtimeEvidenceSource = __esm({
           strategy,
           symbol,
           ...runtimeConfigId ? { runtimeConfigId } : {},
-          ...runtimeReleaseVersion ? { runtimeReleaseVersion } : {},
+          ...runtimeVersion ? { runtimeVersion } : {},
           lineage,
           firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
           lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
@@ -35279,7 +35053,7 @@ var init_runtimeEvidenceSource = __esm({
           strategy: signal.strategy,
           symbol: signal.symbol,
           runtimeConfigId: signal.runtimeConfigId,
-          runtimeReleaseVersion: signal.runtimeReleaseVersion,
+          runtimeVersion: signal.runtimeVersion,
           timestamp: signal.timestamp,
           lineage: signal.runtimeLineage
         });
@@ -35289,7 +35063,7 @@ var init_runtimeEvidenceSource = __esm({
           strategy: evaluation.strategy,
           symbol: evaluation.symbol,
           runtimeConfigId: evaluation.runtimeConfigId,
-          runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
+          runtimeVersion: evaluation.runtimeVersion,
           timestamp: evaluation.timestamp,
           lineage: evaluation.runtimeLineage
         });
@@ -35304,9 +35078,9 @@ var init_runtimeEvidenceSource = __esm({
       expectedUserName,
       expectedWindow
     }) => {
-      const resolvedPath = import_node_path25.default.resolve(projectRoot15, filePath);
+      const resolvedPath = import_node_path24.default.resolve(projectRoot15, filePath);
       const root = asRecord7(
-        JSON.parse(await import_promises30.default.readFile(resolvedPath, "utf8"))
+        JSON.parse(await import_promises29.default.readFile(resolvedPath, "utf8"))
       );
       const runtime = asRecord7(root?.runtime) ?? root;
       if (!root || !runtime) {
@@ -36375,12 +36149,12 @@ var init_runtimeComparison = __esm({
 });
 
 // src/lib/replay/outputReport.ts
-var import_promises31, import_node_path26, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
+var import_promises30, import_node_path25, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
 var init_outputReport = __esm({
   "src/lib/replay/outputReport.ts"() {
     "use strict";
-    import_promises31 = __toESM(require("fs/promises"));
-    import_node_path26 = __toESM(require("path"));
+    import_promises30 = __toESM(require("fs/promises"));
+    import_node_path25 = __toESM(require("path"));
     import_data4 = require("@tradejs/core/data");
     init_support();
     formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
@@ -36631,7 +36405,7 @@ var init_outputReport = __esm({
           existing.gitShas.add("release-versioned");
           existing.dirty.add("n/a");
           existing.gates.add("release-versioned");
-          existing.configs.add(`v${record.lineage.releaseVersion}`);
+          existing.configs.add(`v${record.lineage.version}`);
           existing.contexts.add(
             [
               record.lineage.strategyPackageVersion ?? "strategy:unknown",
@@ -36698,8 +36472,8 @@ var init_outputReport = __esm({
       strategySnapshot,
       runtimeComparison
     }) => {
-      const outputDir = import_node_path26.default.resolve(projectRoot15, "data/replay/output");
-      await import_promises31.default.mkdir(outputDir, { recursive: true });
+      const outputDir = import_node_path25.default.resolve(projectRoot15, "data/replay/output");
+      await import_promises30.default.mkdir(outputDir, { recursive: true });
       const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
       const report = {
         reportType: "replay-output",
@@ -36734,8 +36508,8 @@ var init_outputReport = __esm({
         runtimeComparison,
         perTradeAnalysis
       };
-      const markdownPath = import_node_path26.default.join(outputDir, `${timestamp}-replay-report.md`);
-      const jsonPath = import_node_path26.default.join(outputDir, `${timestamp}-replay-report.json`);
+      const markdownPath = import_node_path25.default.join(outputDir, `${timestamp}-replay-report.md`);
+      const jsonPath = import_node_path25.default.join(outputDir, `${timestamp}-replay-report.json`);
       const lines = [
         "# Replay Report",
         "",
@@ -36801,8 +36575,8 @@ var init_outputReport = __esm({
         ""
       ];
       await Promise.all([
-        import_promises31.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-        import_promises31.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
+        import_promises30.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+        import_promises30.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
 `, "utf8")
       ]);
       return {
@@ -37038,7 +36812,7 @@ __export(signalsSummary_exports, {
   main: () => main44,
   signalsSummary: () => signalsSummary
 });
-var import_config13, import_args33, import_logger12, import_connectors18, import_runtimeDeployments4, flags30, projectRoot14, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml6, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main44;
+var import_config13, import_args33, import_logger12, import_connectors18, import_runtimeStrategies6, flags30, projectRoot14, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml6, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main44;
 var init_signalsSummary = __esm({
   "src/scripts/signalsSummary.ts"() {
     "use strict";
@@ -37052,7 +36826,7 @@ var init_signalsSummary = __esm({
     init_runtimeSignalsLoader();
     init_runtimeSignalsStorage();
     init_runtimeDebugEvidence();
-    import_runtimeDeployments4 = require("@tradejs/infra/runtimeDeployments");
+    import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
     import_args33.default.option(["u", "user"], "Use user config", "root");
     import_args33.default.option(
       "connector",
@@ -37590,7 +37364,7 @@ none`
         loadRuntimeSignals(flags30.user, { startTime, endTime }),
         loadRuntimeSignalEvaluationStatsBuckets(flags30.user),
         loadRuntimeTrades(flags30.user),
-        (0, import_runtimeDeployments4.listRuntimeDeployments)(flags30.user)
+        (0, import_runtimeStrategies6.listRuntimeDeployments)({ userName: flags30.user, projectRoot: projectRoot14 })
       ]);
       const {
         trades: syncedTrades,
@@ -37959,7 +37733,7 @@ var scriptLoaders = {
   "runtime-evidence": () => Promise.resolve().then(() => (init_runtimeEvidence(), runtimeEvidence_exports)),
   "runtime-evidence-sync": () => Promise.resolve().then(() => (init_runtimeEvidenceSync2(), runtimeEvidenceSync_exports)),
   "runtime-scorecard": () => Promise.resolve().then(() => (init_runtimeScorecard2(), runtimeScorecard_exports)),
-  "runtime-config": () => Promise.resolve().then(() => (init_runtimeConfig(), runtimeConfig_exports)),
+  "runtime-control": () => Promise.resolve().then(() => (init_runtimeControl(), runtimeControl_exports)),
   "strategy-release": () => Promise.resolve().then(() => (init_strategyRelease2(), strategyRelease_exports)),
   "server-health": () => Promise.resolve().then(() => (init_serverHealth(), serverHealth_exports)),
   "runtime-parity": () => Promise.resolve().then(() => (init_runtimeParity2(), runtimeParity_exports)),