@tradejs/node 3.1.3 → 3.1.5

package/dist/runtimeDashboard.mjs

@@ -2,28 +2,20 @@ import {
   buildExchangeFallbackRuntimeTrades,
   takeClosedPnlMatch
 } from "./chunk-FB5NUEOQ.mjs";
-import "./chunk-LAJ7NA3Q.mjs";
 import {
   getConnectorCreatorByProvider
 } from "./chunk-3TWULKHV.mjs";
-import "./chunk-W26Y6IRP.mjs";
-import "./chunk-SEQJ6V6B.mjs";
-import {
-  getAvailableStrategyNames
-} from "./chunk-XN7BC7XK.mjs";
 import "./chunk-WS5DYEVZ.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 
 // src/runtimeDashboard.ts
 import { getRuntimeStorageDayKeys } from "@tradejs/core/time";
 import { logger } from "@tradejs/infra/logger";
-import { strategyLogicConfigFingerprint } from "@tradejs/infra/strategyReleaseEvidence";
 import {
   listTradingAccounts,
   resolveTradingAccount
 } from "@tradejs/infra/tradingAccounts";
 import { listRuntimeDeployments } from "@tradejs/infra/runtimeDeployments";
-import { loadRuntimeStrategyConfigs as loadStoredRuntimeStrategyConfigs } from "@tradejs/infra/runtimeStrategyConfigs";
 import { getRuntimeStrategyRelease } from "@tradejs/infra/runtimeStrategyReleases";
 import {
   getData as getData2,
@@ -36,7 +28,6 @@ import {
   isRuntimeTradeRecord,
   selectTradesForWindow,
   toRuntimeTradeView,
-  assignLegacyRuntimeTradeAccountScopes,
   buildRuntimeStrategyIdentityKey
 } from "@tradejs/core/runtimeTrades";
 
@@ -469,31 +460,6 @@ var coerceHours = (value) => {
   }
   return Math.min(MAX_HOURS, Math.max(MIN_HOURS, Math.trunc(parsed)));
 };
-var isRuntimeStrategyConfigEnabled = (config) => {
-  if (!config || typeof config !== "object" || Array.isArray(config)) {
-    return false;
-  }
-  return config.ENABLE !== false;
-};
-var loadRuntimeStrategyConfigs = async (userName) => {
-  return (await loadStoredRuntimeStrategyConfigs(userName)).map(
-    ({ strategyConfig, ...record }) => ({
-      ...record,
-      config: strategyConfig
-    })
-  );
-};
-var loadConfiguredStrategyNames = async (projectRoot) => {
-  try {
-    return await getAvailableStrategyNames(projectRoot);
-  } catch (error) {
-    logger.warn(
-      "strategies runtime: failed to load configured strategies: %s",
-      error?.message || String(error)
-    );
-    return [];
-  }
-};
 var resolveConnectorCreatorByProvider = async (provider, projectRoot) => await getConnectorCreatorByProvider(provider, projectRoot) ?? await getConnectorCreatorByProvider(DEFAULT_PROVIDER, projectRoot) ?? null;
 var resolveConnectorAccountId = async ({
   userName,
@@ -687,8 +653,6 @@ var loadRuntimeDashboard = async ({
     universe: "crypto"
   });
   const [
-    runtimeStrategyConfigs,
-    configuredStrategyNames,
     runtimeTrades,
     activeOrderIds,
     closedPnlRows,
@@ -697,8 +661,6 @@ var loadRuntimeDashboard = async ({
     runtimeDeployments,
     tradingAccounts
   ] = await Promise.all([
-    loadRuntimeStrategyConfigs(userName),
-    loadConfiguredStrategyNames(projectRoot),
     loadRuntimeTrades(userName, { startTime, endTime }),
     loadActiveRuntimeOrderIds(userName),
     loadClosedPnlRows({
@@ -739,10 +701,11 @@ var loadRuntimeDashboard = async ({
   });
   const syncedTrades = [...unsyncedTrades, ...syncedConnectorTrades];
   const fallbackStrategyNames = [
-    .../* @__PURE__ */ new Set([
-      ...runtimeStrategyConfigs.map(({ strategyName }) => strategyName),
-      ...configuredStrategyNames
-    ])
+    ...new Set(
+      runtimeDeployments.flatMap(
+        (deployment) => deployment.strategies.map(({ strategyName }) => strategyName)
+      )
+    )
   ];
   const fallbackTrades = buildExchangeFallbackRuntimeTrades({
     entryRows,
@@ -755,146 +718,71 @@ var loadRuntimeDashboard = async ({
   const allTrades = [...syncedTrades, ...fallbackTrades].filter(
     isRuntimeTradeRecord
   );
-  const connectedSet = new Set(
-    runtimeStrategyConfigs.map(
-      ({ strategyName, configId }) => `${strategyName}:${configId}`
-    )
-  );
   const accountsById = new Map(
     tradingAccounts.map((account) => [account.id, account])
   );
   const runtimeIdentityKey = (trade) => buildRuntimeStrategyIdentityKey({
     strategyName: trade.strategy,
-    configId: trade.runtimeReleaseVersion ? `v${trade.runtimeReleaseVersion}` : trade.runtimeConfigId,
+    configId: trade.runtimeReleaseVersion ? `v${trade.runtimeReleaseVersion}` : void 0,
     universe: trade.universe,
     accountId: trade.accountId,
     deploymentId: trade.deploymentId,
     policyProfileId: trade.policyProfileId
   });
   const identityByKey = /* @__PURE__ */ new Map();
-  const runtimeConfigAccountScopes = new Array();
-  const versionedBindings = /* @__PURE__ */ new Set();
   for (const deployment of runtimeDeployments) {
     for (const deploymentStrategy of deployment.strategies) {
-      const release = deploymentStrategy.releaseVersion ? await getRuntimeStrategyRelease(
+      const release = await getRuntimeStrategyRelease(
         userName,
         deploymentStrategy.strategyName,
         deploymentStrategy.releaseVersion
-      ).catch((error) => {
-        logger.warn(
-          "strategies runtime: failed to load %s v%s: %s",
-          deploymentStrategy.strategyName,
-          deploymentStrategy.releaseVersion,
-          String(error)
-        );
-        return null;
-      }) : null;
-      const deploymentConfig = release?.config ?? (deploymentStrategy.config && typeof deploymentStrategy.config === "object" && !Array.isArray(deploymentStrategy.config) ? deploymentStrategy.config : void 0);
-      const releaseUniverse = release?.config.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
-      const releaseInterval = String(
-        release?.config.INTERVAL ?? deployment.interval
       );
-      const releaseConfigId = deploymentStrategy.releaseVersion ? `v${deploymentStrategy.releaseVersion}` : `deployment-${deployment.id}`;
-      const releasePolicyProfileId = release ? typeof release.config.POLICY_PROFILE_ID === "string" ? release.config.POLICY_PROFILE_ID : void 0 : deploymentStrategy.policyProfileId;
+      if (!release) {
+        throw new Error(
+          `Runtime release not found: ${deploymentStrategy.strategyName} v${deploymentStrategy.releaseVersion}`
+        );
+      }
+      const releaseUniverse = release.config.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
+      const releaseInterval = String(release.config.INTERVAL);
+      const releaseConfigId = `v${deploymentStrategy.releaseVersion}`;
+      const releasePolicyProfileId = typeof release.config.POLICY_PROFILE_ID === "string" ? release.config.POLICY_PROFILE_ID : void 0;
       const runtimeKey = buildRuntimeStrategyIdentityKey({
         strategyName: deploymentStrategy.strategyName,
         configId: releaseConfigId,
-        universe: release ? releaseUniverse : deployment.universe,
+        universe: releaseUniverse,
         accountId: deployment.accountId,
         deploymentId: deployment.id,
         policyProfileId: releasePolicyProfileId
       });
-      if (deploymentStrategy.releaseVersion) {
-        versionedBindings.add(
-          `${deploymentStrategy.strategyName}:${deployment.accountId}`
-        );
-      }
       identityByKey.set(runtimeKey, {
         strategyName: deploymentStrategy.strategyName,
         configId: releaseConfigId,
         releaseVersion: deploymentStrategy.releaseVersion,
-        controlState: deploymentStrategy.controlState ?? "active",
+        controlState: deploymentStrategy.controlState,
         interval: releaseInterval,
-        universe: release ? releaseUniverse : deployment.universe,
+        universe: releaseUniverse,
         accountId: deployment.accountId,
         accountLabel: accountsById.get(deployment.accountId)?.label,
         deploymentId: deployment.id,
         policyProfileId: releasePolicyProfileId,
-        releaseCompositionId: deploymentStrategy.releaseCompositionId,
-        enabled: deployment.enabled && (deploymentStrategy.releaseVersion ? deploymentStrategy.controlState !== "entries_paused" : deploymentStrategy.enabled !== false),
-        config: deploymentConfig,
-        connected: Boolean(release && deployment.enabled),
-        configFingerprint: deploymentConfig ? strategyLogicConfigFingerprint(deploymentConfig) : void 0
+        enabled: deployment.enabled && deploymentStrategy.controlState !== "entries_paused",
+        config: release.config,
+        connected: deployment.enabled
       });
     }
   }
-  for (const runtimeConfig of runtimeStrategyConfigs) {
-    const universe = runtimeConfig.config.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
-    const configuredAccountId = typeof runtimeConfig.config.ACCOUNT_ID === "string" && runtimeConfig.config.ACCOUNT_ID.trim() ? runtimeConfig.config.ACCOUNT_ID.trim() : void 0;
-    const resolvedAccount = await resolveTradingAccount({
-      userName,
-      accountId: configuredAccountId,
-      provider,
-      universe
-    }).catch(() => null);
-    const accountId = resolvedAccount?.id ?? configuredAccountId;
-    if (versionedBindings.has(
-      `${runtimeConfig.strategyName}:${accountId ?? "default"}`
-    )) {
-      continue;
-    }
-    runtimeConfigAccountScopes.push({
-      strategyName: runtimeConfig.strategyName,
-      configId: runtimeConfig.configId,
-      universe,
-      accountId
-    });
-    const runtimeKey = buildRuntimeStrategyIdentityKey({
-      strategyName: runtimeConfig.strategyName,
-      configId: runtimeConfig.configId,
-      universe,
-      accountId
-    });
-    identityByKey.set(runtimeKey, {
-      strategyName: runtimeConfig.strategyName,
-      configId: runtimeConfig.configId,
-      interval: String(runtimeConfig.config.INTERVAL ?? "15"),
-      universe,
-      accountId,
-      accountLabel: accountId ? accountsById.get(accountId)?.label : void 0,
-      enabled: isRuntimeStrategyConfigEnabled(runtimeConfig.config),
-      config: runtimeConfig.config,
-      connected: true,
-      configFingerprint: strategyLogicConfigFingerprint(runtimeConfig.config)
-    });
-  }
-  const accountScopedTrades = assignLegacyRuntimeTradeAccountScopes(
-    allTrades,
-    runtimeConfigAccountScopes
-  );
+  const accountScopedTrades = allTrades;
   for (const trade of accountScopedTrades) {
     const key = runtimeIdentityKey(trade);
-    const configuredCompositionId = identityByKey.get(key)?.releaseCompositionId;
-    const observedCompositionId = trade.runtimeLineage?.schemaVersion === 1 ? trade.runtimeLineage.compositionId : void 0;
-    const releaseCompositionId = configuredCompositionId && observedCompositionId && configuredCompositionId !== observedCompositionId ? void 0 : observedCompositionId ?? configuredCompositionId;
+    const configuredIdentity = identityByKey.get(key);
+    if (!configuredIdentity) continue;
     const releaseVersion = trade.runtimeReleaseVersion ?? (trade.runtimeLineage?.schemaVersion === 2 ? trade.runtimeLineage.releaseVersion : void 0);
+    if (releaseVersion !== configuredIdentity.releaseVersion) continue;
     identityByKey.set(key, {
-      ...identityByKey.get(key),
-      strategyName: trade.strategy,
-      configId: releaseVersion ? `v${releaseVersion}` : trade.runtimeConfigId ?? "config",
-      releaseVersion,
-      interval: String(trade.interval ?? "15"),
-      universe: trade.universe ?? "crypto",
-      accountId: trade.accountId,
-      accountLabel: trade.accountId ? accountsById.get(trade.accountId)?.label : void 0,
-      deploymentId: trade.deploymentId,
-      policyProfileId: trade.policyProfileId,
-      releaseCompositionId,
-      configFingerprint: trade.runtimeLineage?.schemaVersion === 1 ? trade.runtimeLineage.configFingerprint : void 0,
-      gateFingerprint: trade.runtimeLineage?.schemaVersion === 1 ? trade.runtimeLineage.gateFingerprint : void 0,
-      contextFingerprint: trade.runtimeLineage?.schemaVersion === 1 ? trade.runtimeLineage.contextFingerprint : void 0,
-      gitSha: trade.runtimeLineage?.schemaVersion === 1 ? trade.runtimeLineage.gitSha ?? void 0 : void 0,
-      maxLossValue: trade.runtimeLineage?.maxLossValue ?? void 0
+      ...configuredIdentity,
+      interval: String(
+        trade.interval ?? configuredIdentity.interval
+      )
     });
   }
   const evidenceTimelines = await loadStrategyEvidenceTimelines({
@@ -903,12 +791,6 @@ var loadRuntimeDashboard = async ({
     selectors: [...identityByKey.values()].map((identity) => ({
       strategy: identity.strategyName,
       releaseVersion: identity.releaseVersion,
-      compositionId: identity.releaseCompositionId,
-      configFingerprint: identity.configFingerprint,
-      gateFingerprint: identity.gateFingerprint,
-      contextFingerprint: identity.contextFingerprint,
-      gitSha: identity.gitSha,
-      maxLossValue: identity.maxLossValue,
       requireCompleteLineage: true
     })),
     startTime,
@@ -928,7 +810,7 @@ var loadRuntimeDashboard = async ({
         startTime,
         endTime
       });
-      const effectiveStrategyConfig = identity.config ?? null;
+      const effectiveStrategyConfig = identity.config;
       return {
         runtimeKey,
         strategyName,
@@ -941,8 +823,8 @@ var loadRuntimeDashboard = async ({
         accountLabel: identity.accountLabel,
         deploymentId: identity.deploymentId,
         policyProfileId: identity.policyProfileId,
-        connected: identity.connected ?? connectedSet.has(`${strategyName}:${identity.configId}`),
-        enabled: identity.enabled ?? isRuntimeStrategyConfigEnabled(effectiveStrategyConfig),
+        connected: identity.connected,
+        enabled: identity.enabled,
         config: effectiveStrategyConfig,
         symbols: [...new Set(strategyTrades.map((trade) => trade.symbol))],
         stat: analytics.stat,
@@ -952,16 +834,10 @@ var loadRuntimeDashboard = async ({
           strategyEvidenceTimelineSelectorKey({
             strategy: strategyName,
             releaseVersion: identity.releaseVersion,
-            compositionId: identity.releaseCompositionId,
-            configFingerprint: identity.configFingerprint,
-            gateFingerprint: identity.gateFingerprint,
-            contextFingerprint: identity.contextFingerprint,
-            gitSha: identity.gitSha,
-            maxLossValue: identity.maxLossValue,
             requireCompleteLineage: true
           })
         ) ?? {
-          status: "missing",
+          status: "not_attached",
           observedFrom: null,
           markers: []
         },

package/dist/runtimeStrategies.d.mts

@@ -1,27 +1,23 @@
-import { RuntimeStrategyControlState, Interval, MarketUniverse, StrategyCreator, StrategyConfig, StrategyResults, RuntimeDeployment } from '@tradejs/types';
+import { RuntimeStrategyControlState, Interval, MarketUniverse, StrategyCreator, StrategyConfig, RuntimeDeployment } from '@tradejs/types';
 
 interface ResolvedRuntimeStrategy {
     strategyName: string;
-    /** Legacy-only Redis config identity. */
-    configId?: string;
-    releaseVersion?: number;
+    releaseVersion: number;
     controlState: RuntimeStrategyControlState;
     interval: Interval;
     universe: MarketUniverse;
     accountId?: string;
-    strategyPackage?: string | null;
-    strategyPackageVersion?: string | null;
-    runtimePackageVersion?: string | null;
+    strategyPackage: string;
+    strategyPackageVersion: string;
+    runtimePackageVersion: string;
     strategyCreator: StrategyCreator;
     sourceStrategyConfig: StrategyConfig;
     strategyConfig: StrategyConfig;
-    strategyResults: StrategyResults;
 }
-declare const loadResolvedRuntimeStrategies: ({ userName, projectRoot, deployment, connectorName, universe, accountId, interval, }: {
+declare const loadResolvedRuntimeStrategies: ({ userName, projectRoot, deployment, universe, accountId, interval, }: {
     userName: string;
     projectRoot: string;
     deployment?: RuntimeDeployment | null;
-    connectorName?: string;
     universe?: MarketUniverse;
     accountId?: string;
     interval?: Interval;

package/dist/runtimeStrategies.d.ts

@@ -1,27 +1,23 @@
-import { RuntimeStrategyControlState, Interval, MarketUniverse, StrategyCreator, StrategyConfig, StrategyResults, RuntimeDeployment } from '@tradejs/types';
+import { RuntimeStrategyControlState, Interval, MarketUniverse, StrategyCreator, StrategyConfig, RuntimeDeployment } from '@tradejs/types';
 
 interface ResolvedRuntimeStrategy {
     strategyName: string;
-    /** Legacy-only Redis config identity. */
-    configId?: string;
-    releaseVersion?: number;
+    releaseVersion: number;
     controlState: RuntimeStrategyControlState;
     interval: Interval;
     universe: MarketUniverse;
     accountId?: string;
-    strategyPackage?: string | null;
-    strategyPackageVersion?: string | null;
-    runtimePackageVersion?: string | null;
+    strategyPackage: string;
+    strategyPackageVersion: string;
+    runtimePackageVersion: string;
     strategyCreator: StrategyCreator;
     sourceStrategyConfig: StrategyConfig;
     strategyConfig: StrategyConfig;
-    strategyResults: StrategyResults;
 }
-declare const loadResolvedRuntimeStrategies: ({ userName, projectRoot, deployment, connectorName, universe, accountId, interval, }: {
+declare const loadResolvedRuntimeStrategies: ({ userName, projectRoot, deployment, universe, accountId, interval, }: {
     userName: string;
     projectRoot: string;
     deployment?: RuntimeDeployment | null;
-    connectorName?: string;
     universe?: MarketUniverse;
     accountId?: string;
     interval?: Interval;

package/dist/runtimeStrategies.js

@@ -36,9 +36,7 @@ __export(runtimeStrategies_exports, {
 module.exports = __toCommonJS(runtimeStrategies_exports);
 var import_promises = require("fs/promises");
 var import_node_path = __toESM(require("path"));
-var import_redis = require("@tradejs/infra/redis");
 var import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
-var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
 var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
 
 // src/strategy/manifests.ts
@@ -578,6 +576,23 @@ var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest)
     return null;
   }
 };
+var resolveStrategyPackageName = async ({
+  pluginSource,
+  projectRoot
+}) => {
+  if (!pluginSource) return null;
+  if (!pluginSource.startsWith(".") && !import_node_path.default.isAbsolute(pluginSource)) {
+    return pluginSource;
+  }
+  try {
+    const packageJson = JSON.parse(
+      await (0, import_promises.readFile)(import_node_path.default.join(projectRoot, "package.json"), "utf8")
+    );
+    return typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name : null;
+  } catch {
+    return null;
+  }
+};
 var validateReleaseRuntimeCompatibility = async ({
   release,
   projectRoot,
@@ -588,13 +603,17 @@ var validateReleaseRuntimeCompatibility = async ({
     release.strategyPackage,
     packageManifest
   );
-  if (release.strategyPackageVersion && installedStrategyVersion && release.strategyPackageVersion !== installedStrategyVersion) {
+  if (release.strategyPackageVersion !== installedStrategyVersion) {
     throw new Error(
       `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
     );
   }
-  const installedRuntimeVersion = packageManifest.packages?.["@tradejs/node"];
-  if (release.runtimePackageVersion && installedRuntimeVersion && release.runtimePackageVersion !== installedRuntimeVersion) {
+  const installedRuntimeVersion = await resolveInstalledPackageVersion(
+    projectRoot,
+    "@tradejs/node",
+    packageManifest
+  );
+  if (release.runtimePackageVersion !== installedRuntimeVersion) {
     throw new Error(
       `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
     );
@@ -603,24 +622,20 @@ var validateReleaseRuntimeCompatibility = async ({
 var resolveAccountId = async ({
   userName,
   deployment,
-  connectorName,
-  universe,
-  legacyAccountId
+  universe
 }) => {
-  const requestedAccountId = deployment?.accountId ?? legacyAccountId;
   const account = await (0, import_tradingAccounts.resolveTradingAccount)({
     userName,
-    accountId: requestedAccountId,
-    provider: deployment?.provider ?? connectorName,
+    accountId: deployment.accountId,
+    provider: deployment.provider,
     universe
   });
-  return account?.id ?? requestedAccountId;
+  return account?.id ?? deployment.accountId;
 };
 var loadVersionedRuntimeStrategies = async ({
   userName,
   projectRoot,
-  deployment,
-  connectorName
+  deployment
 }) => {
   const packageManifest = await readPackageManifest(projectRoot);
   return Promise.all(
@@ -630,9 +645,14 @@ var loadVersionedRuntimeStrategies = async ({
           `Deployment ${deployment.id} strategy ${reference.strategyName} has no releaseVersion`
         );
       }
-      if (reference.config && Object.keys(reference.config).length) {
+      if (Object.keys(reference).some(
+        (key) => !["strategyName", "releaseVersion", "controlState"].includes(key)
+      )) {
+        throw new Error(`Deployment ${deployment.id} has invalid fields`);
+      }
+      if (!reference.controlState) {
         throw new Error(
-          `Deployment ${deployment.id} must not embed config for ${reference.strategyName}`
+          `Deployment ${deployment.id} strategy ${reference.strategyName} has no controlState`
         );
       }
       const release = await (0, import_runtimeStrategyReleases.getRuntimeStrategyRelease)(
@@ -662,13 +682,12 @@ var loadVersionedRuntimeStrategies = async ({
       const accountId = await resolveAccountId({
         userName,
         deployment,
-        connectorName,
         universe
       });
       return {
         strategyName: reference.strategyName,
         releaseVersion: release.releaseVersion,
-        controlState: reference.controlState ?? "active",
+        controlState: reference.controlState,
         interval,
         universe,
         accountId,
@@ -677,90 +696,24 @@ var loadVersionedRuntimeStrategies = async ({
         runtimePackageVersion: release.runtimePackageVersion,
         strategyCreator,
         sourceStrategyConfig: release.config,
-        strategyConfig: release.config,
-        // Symbol result configs are mutable legacy overlays and are not read by v2.
-        strategyResults: {}
+        strategyConfig: release.config
       };
     })
   );
 };
-var loadLegacyRuntimeStrategies = async ({
-  userName,
-  projectRoot,
-  deployment,
-  connectorName
-}) => {
-  const deploymentStrategies = new Map(
-    (deployment?.strategies ?? []).map((strategy) => [
-      strategy.strategyName,
-      strategy
-    ])
-  );
-  const candidates = await Promise.all(
-    (await (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName)).map(async (record) => {
-      const binding = deploymentStrategies.get(record.strategyName);
-      if (binding?.enabled === false || record.strategyConfig.ENABLE === false) {
-        return null;
-      }
-      const universe = record.strategyConfig.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
-      const interval = String(
-        record.strategyConfig.INTERVAL ?? "15"
-      );
-      const accountId = await resolveAccountId({
-        userName,
-        deployment,
-        connectorName,
-        universe,
-        legacyAccountId: typeof record.strategyConfig.ACCOUNT_ID === "string" ? record.strategyConfig.ACCOUNT_ID : void 0
-      });
-      const [strategyCreator, strategyResults] = await Promise.all([
-        getStrategyCreator(record.strategyName, projectRoot),
-        (0, import_redis.getData)(import_redis.redisKeys.strategyResults(userName, record.strategyName), {})
-      ]);
-      if (!strategyCreator) return null;
-      return {
-        strategyName: record.strategyName,
-        configId: record.configId,
-        controlState: "active",
-        interval,
-        universe,
-        accountId,
-        strategyCreator,
-        sourceStrategyConfig: record.strategyConfig,
-        strategyConfig: record.strategyConfig,
-        strategyResults: strategyResults ?? {}
-      };
-    })
-  );
-  return candidates.filter(Boolean);
-};
 var loadResolvedRuntimeStrategies = async ({
   userName,
   projectRoot,
   deployment,
-  connectorName = "bybit",
   universe,
   accountId,
   interval
 }) => {
-  const hasVersionedReferences = Boolean(
-    deployment?.strategies.some((strategy) => strategy.releaseVersion != null)
-  );
-  if (hasVersionedReferences && deployment?.strategies.some((strategy) => strategy.releaseVersion == null)) {
-    throw new Error(
-      `Deployment ${deployment.id} mixes legacy configs and versioned releases`
-    );
-  }
-  const strategies2 = hasVersionedReferences ? await loadVersionedRuntimeStrategies({
+  if (!deployment) throw new Error("Runtime deployment is required");
+  const strategies2 = await loadVersionedRuntimeStrategies({
     userName,
     projectRoot,
-    deployment,
-    connectorName
-  }) : await loadLegacyRuntimeStrategies({
-    userName,
-    projectRoot,
-    deployment,
-    connectorName
+    deployment
   });
   const filtered = strategies2.filter(
     (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
@@ -780,7 +733,11 @@ var getRuntimeStrategyPackageMetadata = async ({
   projectRoot
 }) => {
   const packageManifest = await readPackageManifest(projectRoot);
-  const strategyPackage = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
+  const pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
+  const strategyPackage = await resolveStrategyPackageName({
+    pluginSource,
+    projectRoot
+  });
   return {
     strategyPackage,
     strategyPackageVersion: await resolveInstalledPackageVersion(