@tradejs/node 3.1.11 → 3.1.12-beta.218

package/dist/runtimeStrategies.js

@@ -30,13 +30,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtimeStrategies.ts
 var runtimeStrategies_exports = {};
 __export(runtimeStrategies_exports, {
+  RUNTIME_PACKAGE_MANIFEST_SCHEMA: () => RUNTIME_PACKAGE_MANIFEST_SCHEMA,
+  computeDeploymentCompositionId: () => computeDeploymentCompositionId,
+  computeStrategyRevision: () => computeStrategyRevision,
   getRuntimeDeployment: () => getRuntimeDeployment,
   getRuntimeStrategyPackageMetadata: () => getRuntimeStrategyPackageMetadata,
   listRuntimeDeployments: () => listRuntimeDeployments,
   loadResolvedRuntimeStrategies: () => loadResolvedRuntimeStrategies,
+  resolveRuntimeComposition: () => resolveRuntimeComposition,
   verifyRuntimeDeclaration: () => verifyRuntimeDeclaration
 });
 module.exports = __toCommonJS(runtimeStrategies_exports);
+var import_node_crypto4 = require("crypto");
 var import_promises = require("fs/promises");
 var import_node_path = __toESM(require("path"));
 var import_runtimeControls = require("@tradejs/infra/runtimeControls");
@@ -45,10 +50,10 @@ var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
 // src/strategyRuntime.ts
 var import_constants5 = require("@tradejs/core/constants");
 var import_strategies6 = require("@tradejs/core/strategies");
-var import_logger11 = require("@tradejs/infra/logger");
+var import_logger10 = require("@tradejs/infra/logger");
 
 // src/strategyHelpers/runtime.ts
-var import_logger9 = require("@tradejs/infra/logger");
+var import_logger8 = require("@tradejs/infra/logger");
 var import_constants3 = require("@tradejs/core/constants");
 var import_ml2 = require("@tradejs/infra/ml");
 
@@ -630,7 +635,6 @@ var buildAiMarketContext = (signal) => ({
 
 // src/strategy/manifests.ts
 var import_indicators = require("@tradejs/core/indicators");
-var import_logger2 = require("@tradejs/infra/logger");
 
 // src/tradejsConfig.ts
 var import_fs = __toESM(require("fs"));
@@ -983,21 +987,34 @@ var extractIndicatorPluginDefinition = (moduleExport) => {
   );
   return indicatorEntries ? { indicatorEntries } : null;
 };
-var registerEntries = (entries, source, state) => {
-  for (const entry of entries) {
-    const strategyName = entry.manifest?.name;
-    if (!strategyName) {
-      import_logger2.logger.warn("Skip strategy entry without name from %s", source);
-      continue;
+var validateStrategyEntries = (moduleName, entries, state) => {
+  const issues = [];
+  const names = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const entryPath = `${moduleName}.strategyEntries[${index}]`;
+    const strategyName = entry?.manifest?.name;
+    if (typeof strategyName !== "string" || !strategyName.trim()) {
+      issues.push(`${entryPath}: manifest.name is required`);
+    } else if (names.has(strategyName) || state.strategyEntriesMap.has(strategyName)) {
+      issues.push(`${entryPath}: duplicate strategy ${strategyName}`);
+    } else {
+      names.add(strategyName);
     }
-    if (state.strategyCreators.has(strategyName)) {
-      import_logger2.logger.warn(
-        'Skip duplicate strategy "%s" from %s: already registered',
-        strategyName,
-        source
-      );
-      continue;
+    if (!entry || typeof entry !== "object" || !entry.defaults || typeof entry.defaults !== "object" || Array.isArray(entry.defaults)) {
+      issues.push(`${entryPath}: defaults must be an object`);
+    }
+    if (typeof entry?.parseConfig !== "function") {
+      issues.push(`${entryPath}: parseConfig is required`);
+    }
+    if (typeof entry?.createCore !== "function") {
+      issues.push(`${entryPath}: createCore is required`);
     }
+  });
+  return issues;
+};
+var registerEntries = (entries, source, state) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest.name;
     state.strategyManifestsMap.set(strategyName, entry.manifest);
     state.strategyEntriesMap.set(strategyName, entry);
     state.strategySourcesMap.set(strategyName, source);
@@ -1054,6 +1071,7 @@ var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
       if (!pluginModuleNames.length) {
         return;
       }
+      const issues = [];
       for (const moduleName of pluginModuleNames) {
         try {
           const resolvedModuleName = resolvePluginModuleSpecifier(
@@ -1067,24 +1085,30 @@ var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           if (strategySet.has(moduleName)) {
             const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
             if (!pluginDefinition) {
-              import_logger2.logger.warn(
-                'Skip strategy plugin "%s": export { strategyEntries } is missing',
-                moduleName
+              issues.push(
+                `${moduleName}: export { strategyEntries } is missing`
               );
             } else {
-              registerEntries(
-                pluginDefinition.strategyEntries,
+              const entryIssues = validateStrategyEntries(
                 moduleName,
+                pluginDefinition.strategyEntries,
                 state
               );
+              issues.push(...entryIssues);
+              if (entryIssues.length === 0) {
+                registerEntries(
+                  pluginDefinition.strategyEntries,
+                  moduleName,
+                  state
+                );
+              }
             }
           }
           if (indicatorSet.has(moduleName)) {
             const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
             if (!indicatorPluginDefinition) {
-              import_logger2.logger.warn(
-                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
-                moduleName
+              issues.push(
+                `${moduleName}: export { indicatorEntries } is missing`
               );
             } else {
               (0, import_indicators.registerIndicatorEntries)(
@@ -1095,19 +1119,17 @@ var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
             }
           }
           if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
-            import_logger2.logger.warn(
-              'Skip plugin "%s": no strategy/indicator sections requested in config',
-              moduleName
-            );
+            issues.push(`${moduleName}: plugin is not declared in config`);
           }
         } catch (error) {
-          import_logger2.logger.warn(
-            'Failed to load plugin "%s": %s',
-            moduleName,
-            String(error)
-          );
+          issues.push(`${moduleName}: failed to import: ${String(error)}`);
         }
       }
+      if (issues.length > 0) {
+        throw new Error(
+          ["Invalid TradeJS plugin catalog:", ...issues].join("\n")
+        );
+      }
     })();
   }
   await state.pluginsLoadPromise;
@@ -1117,6 +1139,11 @@ var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyCreators.get(name);
 };
+var getStrategyEntry = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyEntriesMap.get(name);
+};
 var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
@@ -1769,7 +1796,7 @@ var import_node_crypto = require("crypto");
 var import_constants = require("@tradejs/core/constants");
 var import_time = require("@tradejs/core/time");
 var import_trade = require("@tradejs/core/trade");
-var import_logger3 = require("@tradejs/infra/logger");
+var import_logger2 = require("@tradejs/infra/logger");
 var import_redis2 = require("@tradejs/infra/redis");
 var now = () => Date.now();
 var toRandomOrderSuffix = () => (0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 12).toLowerCase();
@@ -1828,7 +1855,7 @@ var recordRuntimeTradeOpen = async (params) => {
       )
     ]);
   } catch (error) {
-    import_logger3.logger.error(
+    import_logger2.logger.error(
       "runtime trade open journal failed: %s %s",
       record.symbol,
       error?.message || String(error)
@@ -1895,7 +1922,7 @@ var recordRuntimeTradeIncrease = async (params) => {
       )
     ]);
   } catch (error) {
-    import_logger3.logger.error(
+    import_logger2.logger.error(
       "runtime trade increase journal failed: %s %s",
       symbol,
       error?.message || String(error)
@@ -2002,7 +2029,7 @@ var markRuntimeTradeClosed = async (params) => {
       )
     ]);
   } catch (error) {
-    import_logger3.logger.error(
+    import_logger2.logger.error(
       "runtime trade close journal failed: %s %s",
       symbol,
       error?.message || String(error)
@@ -2012,11 +2039,11 @@ var markRuntimeTradeClosed = async (params) => {
 };
 
 // src/strategyHelpers/marketContextStages.ts
-var import_logger8 = require("@tradejs/infra/logger");
+var import_logger7 = require("@tradejs/infra/logger");
 
 // src/strategyHelpers/binanceMarketContext.ts
 var import_marketContext = require("@tradejs/infra/timescale/marketContext");
-var import_logger4 = require("@tradejs/infra/logger");
+var import_logger3 = require("@tradejs/infra/logger");
 var import_strategies = require("@tradejs/core/strategies");
 
 // src/binanceBreadthUniverses.ts
@@ -2612,7 +2639,7 @@ var enrichSignalWithBinanceMarketContext = async (params) => {
       throw error;
     }
     binanceMarketContextUnavailable = true;
-    import_logger4.logger.warn(
+    import_logger3.logger.warn(
       "Binance market context disabled after Timescale read failure: %s",
       String(error)
     );
@@ -2622,7 +2649,7 @@ var enrichSignalWithBinanceMarketContext = async (params) => {
 
 // src/strategyHelpers/coinMarketCapContext.ts
 var import_strategies2 = require("@tradejs/core/strategies");
-var import_logger5 = require("@tradejs/infra/logger");
+var import_logger4 = require("@tradejs/infra/logger");
 var import_marketContext2 = require("@tradejs/infra/timescale/marketContext");
 var DEFAULT_MAX_AGE_MS = 48 * 60 * 6e4;
 var SOURCE_GLOBAL_DAILY = "coinmarketcap_global";
@@ -3111,7 +3138,7 @@ var enrichSignalWithCoinMarketCapContext = async (params) => {
       throw error;
     }
     coinMarketCapContextUnavailable = true;
-    import_logger5.logger.warn(
+    import_logger4.logger.warn(
       "CoinMarketCap context disabled after Timescale read failure: %s",
       String(error)
     );
@@ -3125,7 +3152,7 @@ var import_data = require("@tradejs/core/data");
 var import_strategies3 = require("@tradejs/core/strategies");
 var import_constants2 = require("@tradejs/core/constants");
 var import_derivatives = require("@tradejs/infra/timescale/derivatives");
-var import_logger6 = require("@tradejs/infra/logger");
+var import_logger5 = require("@tradejs/infra/logger");
 var STORED_INTERVALS = ["15m", "1h"];
 var CONTEXT_INTERVALS = ["15m", "1h"];
 var DEFAULT_LOOKBACK_HOURS = 48;
@@ -3357,7 +3384,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
       throw error;
     }
     derivativesContextUnavailable = true;
-    import_logger6.logger.warn(
+    import_logger5.logger.warn(
       "Derivatives context disabled after Timescale read failure: %s",
       String(error)
     );
@@ -3369,7 +3396,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
 var import_data2 = require("@tradejs/core/data");
 var import_strategies4 = require("@tradejs/core/strategies");
 var import_hyperliquidWhales2 = require("@tradejs/infra/timescale/hyperliquidWhales");
-var import_logger7 = require("@tradejs/infra/logger");
+var import_logger6 = require("@tradejs/infra/logger");
 
 // src/hyperliquidWhaleUniverse.ts
 var import_node_crypto3 = require("crypto");
@@ -3889,7 +3916,7 @@ var loadHyperliquidWhaleFlowContext = async (params) => {
       throw error;
     }
     hyperliquidWhaleContextUnavailable = true;
-    import_logger7.logger.warn(
+    import_logger6.logger.warn(
       "Hyperliquid whale context disabled after Timescale read failure: %s",
       String(error)
     );
@@ -3972,7 +3999,7 @@ var runMarketContextStage = async ({
       elapsedMs: Date.now() - startedAt
     };
     if (status === "timed_out") {
-      import_logger8.logger.warn(
+      import_logger7.logger.warn(
         "Market context stage timed out: %s after %sms",
         stage,
         result.elapsedMs
@@ -4162,7 +4189,7 @@ var enrichSignalWithAi = async ({
     signal.aiAnalysis = analysis;
     return resolveAiQuality(analysis, direction);
   } catch (err) {
-    import_logger9.logger.error("AI analysis error: %s %s", symbol, formatAiError(err));
+    import_logger8.logger.error("AI analysis error: %s %s", symbol, formatAiError(err));
   }
   return void 0;
 };
@@ -4197,7 +4224,7 @@ var getOrderArrivalSnapshot = async ({
       spreadBps
     };
   } catch (error) {
-    import_logger9.logger.warn(
+    import_logger8.logger.warn(
       "runtime order arrival snapshot failed: %s %s",
       symbol,
       error?.message || String(error)
@@ -4426,7 +4453,7 @@ var executeEntryOrder = async ({
       deploymentId: signal.deploymentId,
       policyProfileId: signal.policyProfileId,
       runtimeConfigId: signal.runtimeConfigId,
-      runtimeVersion: signal.runtimeVersion,
+      strategyRevision: signal.strategyRevision,
       runtimeLineage: signal.runtimeLineage,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
     });
@@ -4978,7 +5005,7 @@ var canUseSharedReplayState = ({
 }) => (env === "BACKTEST" || env === "PARITY") && Boolean(sharedReplayKey);
 
 // src/strategy/runtimeExecution.ts
-var import_logger10 = require("@tradejs/infra/logger");
+var import_logger9 = require("@tradejs/infra/logger");
 var import_types = require("@tradejs/types");
 var buildExitOrderSignal = ({
   strategyName,
@@ -5030,7 +5057,7 @@ var handleExitDecision = async ({
         deploymentId: connector.deploymentId
       });
       if (!activeTrade) {
-        import_logger10.logger.warn(
+        import_logger9.logger.warn(
           "[%s] blocked closePosition for untracked runtime position: %s",
           strategyName ?? "unknown",
           symbol
@@ -5038,7 +5065,7 @@ var handleExitDecision = async ({
         return "CLOSE_BLOCKED_BY_UNTRACKED_POSITION";
       }
       if (!strategyName || activeTrade.strategy !== strategyName) {
-        import_logger10.logger.warn(
+        import_logger9.logger.warn(
           "[%s] blocked closePosition for foreign runtime position: %s ownedBy=%s",
           strategyName ?? "unknown",
           symbol,
@@ -5090,7 +5117,7 @@ var handleExitDecision = async ({
           exitType: closedTrade?.exitType ?? "exit"
         });
       } catch (notificationError) {
-        import_logger10.logger.error(
+        import_logger9.logger.error(
           "runtime close notification error: %s %s",
           symbol,
           notificationError
@@ -5104,7 +5131,7 @@ var handleExitDecision = async ({
       decision,
       market
     });
-    import_logger10.logger.error("close order error: %s %s", symbol, err);
+    import_logger9.logger.error("close order error: %s %s", symbol, err);
     return "ORDER_ERROR";
   }
   return decision.code;
@@ -5131,7 +5158,7 @@ var handleProtectDecision = async ({
       decision,
       market
     });
-    import_logger10.logger.error("protect position error: %s %s", symbol, err);
+    import_logger9.logger.error("protect position error: %s %s", symbol, err);
     return "ORDER_ERROR";
   }
   return decision.code;
@@ -5294,9 +5321,9 @@ var executeEntryDecision = async ({
       market
     });
     if (err?.message === import_types.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
-      import_logger10.logger.warn("order warning: %s %s", symbol, err);
+      import_logger9.logger.warn("order warning: %s %s", symbol, err);
     } else {
-      import_logger10.logger.error("order error: %s %s", symbol, err);
+      import_logger9.logger.error("order error: %s %s", symbol, err);
     }
     return signal ?? "ORDER_ERROR";
   }
@@ -5337,7 +5364,7 @@ var createStrategyRuntime = ({
     deploymentId: requestedDeploymentId,
     policyProfileId,
     runtimeConfigId,
-    runtimeVersion,
+    strategyRevision,
     entriesPaused = false,
     runtimeLineage,
     runtimeConfigSnapshot,
@@ -5450,7 +5477,7 @@ var createStrategyRuntime = ({
         try {
           await projectHook(errorParams);
         } catch (hookError) {
-          import_logger11.logger.error(
+          import_logger10.logger.error(
             "project hook onRuntimeError failed: %s %s",
             strategyName,
             hookError
@@ -5464,7 +5491,7 @@ var createStrategyRuntime = ({
       try {
         await onRuntimeError(errorParams);
       } catch (hookError) {
-        import_logger11.logger.error(
+        import_logger10.logger.error(
           "runtime hook onRuntimeError failed: %s %s",
           strategyName,
           hookError
@@ -5478,7 +5505,7 @@ var createStrategyRuntime = ({
       try {
         return await hook(params);
       } catch (error) {
-        import_logger11.logger.error(
+        import_logger10.logger.error(
           'strategy hook "%s" failed for %s: %s',
           stage,
           strategyName,
@@ -6009,8 +6036,8 @@ var createStrategyRuntime = ({
             signal.signalId = `${signal.signalId}:${runtimeConfigId}`;
           }
         }
-        if (runtimeVersion) {
-          signal.runtimeVersion = runtimeVersion;
+        if (strategyRevision) {
+          signal.strategyRevision = strategyRevision;
         }
         if (decisionHookCtx.policyProfileId) {
           signal.policyProfileId = decisionHookCtx.policyProfileId;
@@ -6123,7 +6150,7 @@ var createStrategyRuntime = ({
         if (signal) {
           signal.orderStatus = "skipped";
           signal.orderSkipReason = skipReason;
-          signal.runtimeVersion = runtimeVersion;
+          signal.strategyRevision = strategyRevision;
         }
         return signal ?? skipReason;
       }
@@ -6235,6 +6262,7 @@ var createStrategyRuntime = ({
 setStrategyRuntimeFactory(createStrategyRuntime);
 
 // src/runtimeStrategies.ts
+var RUNTIME_PACKAGE_MANIFEST_SCHEMA = "tradejs-runtime-package-manifest/v1";
 var INTERVALS = /* @__PURE__ */ new Set([
   "1",
   "3",
@@ -6261,7 +6289,7 @@ var DEPLOYMENT_KEYS = /* @__PURE__ */ new Set([
   "assetClasses",
   "tickers"
 ]);
-var STRATEGY_KEYS = /* @__PURE__ */ new Set(["version", "enabled", "selection", "config"]);
+var STRATEGY_KEYS = /* @__PURE__ */ new Set(["generation", "enabled", "selection", "config"]);
 var SELECTION_KEYS = /* @__PURE__ */ new Set(["tickers"]);
 var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "ACCOUNT_ID",
@@ -6270,60 +6298,165 @@ var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "ENABLE"
 ]);
 var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var readPackageManifest = async (projectRoot) => {
-  const candidates = [
-    process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
-    import_node_path.default.join(projectRoot, "runtime-package-manifest.json"),
-    "/app/runtime-package-manifest.json"
-  ].filter((candidate) => Boolean(candidate));
-  for (const candidate of candidates) {
-    try {
-      return JSON.parse(
-        await (0, import_promises.readFile)(candidate, "utf8")
-      );
-    } catch {
-    }
+var normalizeForCanonicalJson = (value) => {
+  if (Array.isArray(value)) return value.map(normalizeForCanonicalJson);
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nestedValue]) => [
+        key,
+        normalizeForCanonicalJson(nestedValue)
+      ])
+    );
   }
-  return { packages: {} };
+  return value;
 };
-var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest) => {
-  if (!packageName || packageName === "runtime") return null;
-  const manifestVersion = manifest.packages?.[packageName];
-  if (manifestVersion) return manifestVersion;
+var revision = (prefix, value) => `${prefix}:${(0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(normalizeForCanonicalJson(value))).digest("hex").slice(0, 16)}`;
+var computeStrategyRevision = ({
+  strategyName,
+  strategyPackage,
+  strategyPackageVersion,
+  strategyDependencyVersions,
+  runtimePackageVersion,
+  strategyConfig
+}) => revision("sr1", {
+  schema: "tradejs-strategy-revision/v1",
+  strategyName,
+  strategyPackage,
+  strategyPackageVersion,
+  strategyDependencyVersions,
+  runtimePackageVersion,
+  strategyConfig
+});
+var computeDeploymentCompositionId = (value) => revision("dc1", {
+  schema: "tradejs-deployment-composition/v1",
+  ...value,
+  assetClasses: value.assetClasses ? [...value.assetClasses].sort((left, right) => left.localeCompare(right)) : void 0,
+  strategies: [...value.strategies].sort(
+    (left, right) => left.strategyName.localeCompare(right.strategyName)
+  ).map((strategy) => ({
+    ...strategy,
+    selection: strategy.selection ? {
+      tickers: [...strategy.selection.tickers].sort(
+        (left, right) => left.localeCompare(right)
+      )
+    } : void 0
+  }))
+});
+var readRuntimePackageManifest = async (projectRoot) => {
+  const manifestPath = process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST?.trim() || import_node_path.default.join(projectRoot, "runtime-package-manifest.json");
+  let value;
   try {
-    const packageJsonPath = import_node_path.default.join(
-      projectRoot,
-      "node_modules",
-      ...packageName.split("/"),
-      "package.json"
+    value = JSON.parse(await (0, import_promises.readFile)(manifestPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Unable to read runtime package manifest ${manifestPath}: ${String(error)}`
     );
+  }
+  if (!isRecord(value) || Object.keys(value).some(
+    (key) => !["schema", "projectSha", "packages"].includes(key)
+  ) || value.schema !== RUNTIME_PACKAGE_MANIFEST_SCHEMA || typeof value.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(value.projectSha) || !isRecord(value.packages) || Object.keys(value.packages).length === 0 || Object.entries(value.packages).some(
+    ([packageName, version]) => !packageName.trim() || typeof version !== "string" || !version.trim()
+  )) {
+    throw new Error(`Invalid runtime package manifest: ${manifestPath}`);
+  }
+  return value;
+};
+var readInstalledPackageMetadata = async ({
+  projectRoot,
+  packageName,
+  projectPackage
+}) => {
+  const packageJsonPath = projectPackage ? import_node_path.default.join(projectRoot, "package.json") : import_node_path.default.join(
+    projectRoot,
+    "node_modules",
+    ...packageName.split("/"),
+    "package.json"
+  );
+  try {
     const packageJson = JSON.parse(await (0, import_promises.readFile)(packageJsonPath, "utf8"));
-    return packageJson.version ?? null;
-  } catch {
-    return null;
+    if (packageJson.name !== void 0 && packageJson.name !== packageName || typeof packageJson.version !== "string" || !packageJson.version.trim()) {
+      throw new Error("name or version is invalid");
+    }
+    const dependencyNames = [
+      ...isRecord(packageJson.dependencies) ? Object.keys(packageJson.dependencies) : [],
+      ...isRecord(packageJson.peerDependencies) ? Object.keys(packageJson.peerDependencies) : []
+    ];
+    return {
+      version: packageJson.version,
+      runtimeDependencies: [...new Set(dependencyNames)].filter((name) => name.startsWith("@tradejs/")).sort((left, right) => left.localeCompare(right))
+    };
+  } catch (error) {
+    throw new Error(
+      `Installed package manifest not found for ${packageName}: ${String(error)}`
+    );
   }
 };
-var resolveStrategyPackageName = async ({
+var resolveVerifiedPackageVersion = async ({
+  projectRoot,
+  packageName,
+  manifest,
+  projectPackage = false
+}) => {
+  const declaredVersion = manifest.packages[packageName];
+  if (!declaredVersion) {
+    throw new Error(`Runtime package manifest is missing ${packageName}`);
+  }
+  const installed = await readInstalledPackageMetadata({
+    projectRoot,
+    packageName,
+    projectPackage
+  });
+  if (declaredVersion !== installed.version) {
+    throw new Error(
+      `Runtime package manifest mismatch for ${packageName}: declared=${declaredVersion} installed=${installed.version}`
+    );
+  }
+  return installed.version;
+};
+var resolveVerifiedStrategyDependencyVersions = async ({
+  projectRoot,
+  strategyPackage,
+  manifest
+}) => {
+  const metadata = await readInstalledPackageMetadata({
+    projectRoot,
+    packageName: strategyPackage.name,
+    projectPackage: strategyPackage.projectPackage
+  });
+  return Object.fromEntries(
+    await Promise.all(
+      metadata.runtimeDependencies.map(async (packageName) => [
+        packageName,
+        await resolveVerifiedPackageVersion({
+          projectRoot,
+          packageName,
+          manifest
+        })
+      ])
+    )
+  );
+};
+var resolveStrategyPackage = async ({
   pluginSource,
   projectRoot
 }) => {
   if (!pluginSource) return null;
   if (!pluginSource.startsWith(".") && !import_node_path.default.isAbsolute(pluginSource)) {
-    return pluginSource;
+    return { name: pluginSource, projectPackage: false };
   }
   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;
+    return typeof packageJson.name === "string" && packageJson.name.trim() ? { name: packageJson.name, projectPackage: true } : null;
   } catch {
     return null;
   }
 };
-var verifyStringArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
-var verifyStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => SELECTION_KEYS.has(key)) && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every(
-  (ticker) => typeof ticker === "string" && ticker.trim().length > 0
-);
+var verifyStringSet = (value) => value === void 0 || Array.isArray(value) && value.length > 0 && value.every(
+  (item) => typeof item === "string" && item.length > 0 && item === item.trim()
+) && new Set(value).size === value.length;
+var verifyStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => SELECTION_KEYS.has(key)) && value.tickers !== void 0 && verifyStringSet(value.tickers);
 var cloneSelection = (selection) => selection ? { tickers: [...selection.tickers] } : void 0;
 var resolveStrategySelection = ({
   deployment,
@@ -6332,13 +6465,13 @@ var resolveStrategySelection = ({
   strategy.selection ?? (deployment.tickers ? { tickers: deployment.tickers } : void 0)
 );
 var verifyDeploymentDeclaration = (deploymentId, value) => {
-  if (!deploymentId.trim() || !isRecord(value) || Object.keys(value).some((key) => !DEPLOYMENT_KEYS.has(key)) || typeof value.connectorName !== "string" || !value.connectorName.trim() || typeof value.accountId !== "string" || !value.accountId.trim() || value.label !== void 0 && typeof value.label !== "string" || value.provider !== void 0 && typeof value.provider !== "string" || value.enabled !== void 0 && typeof value.enabled !== "boolean" || !verifyStringArray(value.assetClasses) || !verifyStringArray(value.tickers) || !isRecord(value.strategies) || !Object.keys(value.strategies).length) {
+  if (!deploymentId.trim() || !isRecord(value) || Object.keys(value).some((key) => !DEPLOYMENT_KEYS.has(key)) || typeof value.connectorName !== "string" || !value.connectorName.trim() || typeof value.accountId !== "string" || !value.accountId.trim() || value.label !== void 0 && typeof value.label !== "string" || value.provider !== void 0 && typeof value.provider !== "string" || value.enabled !== void 0 && typeof value.enabled !== "boolean" || !verifyStringSet(value.assetClasses) || !verifyStringSet(value.tickers) || !isRecord(value.strategies) || !Object.keys(value.strategies).length) {
     throw new Error(`Invalid runtime deployment declaration: ${deploymentId}`);
   }
   for (const [strategyName, strategyValue] of Object.entries(
     value.strategies
   )) {
-    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || !Number.isSafeInteger(strategyValue.version) || Number(strategyValue.version) <= 0 || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
+    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || strategyValue.generation !== void 0 && (typeof strategyValue.generation !== "string" || !strategyValue.generation.trim()) || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
       (key) => FORBIDDEN_CONFIG_KEYS.has(key)
     ) || !INTERVALS.has(String(strategyValue.config.INTERVAL)) || !["crypto", "tradfi"].includes(String(strategyValue.config.UNIVERSE))) {
       throw new Error(
@@ -6357,55 +6490,180 @@ var verifyRuntimeDeclaration = (value) => {
   }
   return value;
 };
-var toRuntimeDeployment = ({
-  id,
+var loadRuntimeDeclaration = async (projectRoot) => {
+  const projectConfig = await loadTradejsConfig(projectRoot);
+  if (!projectConfig.runtime) {
+    throw new Error("Runtime declaration is required in tradejs.config.ts");
+  }
+  return verifyRuntimeDeclaration(projectConfig.runtime);
+};
+var resolveStrategyComposition = async ({
+  strategyName,
   declaration,
+  deployment,
+  projectRoot,
+  packageManifest
+}) => {
+  const [strategyEntry, strategyCreator, pluginSource] = await Promise.all([
+    getStrategyEntry(strategyName, projectRoot),
+    getStrategyCreator(strategyName, projectRoot),
+    getStrategyPluginSource(strategyName, projectRoot)
+  ]);
+  if (!strategyEntry || !strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
+  }
+  if (typeof strategyEntry.parseConfig !== "function") {
+    throw new Error(`Strategy config parser is missing: ${strategyName}`);
+  }
+  const strategyPackage = await resolveStrategyPackage({
+    pluginSource: pluginSource ?? null,
+    projectRoot
+  });
+  if (!strategyPackage) {
+    throw new Error(`Installed strategy package not found: ${strategyName}`);
+  }
+  const [
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion
+  ] = await Promise.all([
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: strategyPackage.name,
+      projectPackage: strategyPackage.projectPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedStrategyDependencyVersions({
+      projectRoot,
+      strategyPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: "@tradejs/node",
+      manifest: packageManifest
+    })
+  ]);
+  const parsedConfig = strategyEntry.parseConfig(declaration.config);
+  if (!isRecord(parsedConfig)) {
+    throw new Error(
+      `Strategy config parser returned a non-object: ${strategyName}`
+    );
+  }
+  const strategyConfig = parsedConfig;
+  const selection = resolveStrategySelection({
+    deployment,
+    strategy: declaration
+  });
+  return {
+    strategyName,
+    strategyRevision: computeStrategyRevision({
+      strategyName,
+      strategyPackage: strategyPackage.name,
+      strategyPackageVersion,
+      strategyDependencyVersions,
+      runtimePackageVersion,
+      strategyConfig
+    }),
+    ...declaration.generation ? { generation: declaration.generation } : {},
+    enabled: declaration.enabled,
+    interval: String(strategyConfig.INTERVAL),
+    universe: strategyConfig.UNIVERSE,
+    strategyPackage: strategyPackage.name,
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion,
+    strategyCreator,
+    sourceStrategyConfig: declaration.config,
+    strategyConfig,
+    ...selection ? { selection } : {}
+  };
+};
+var resolveRuntimeComposition = async ({
+  projectRoot
+}) => {
+  const [runtime, packageManifest] = await Promise.all([
+    loadRuntimeDeclaration(projectRoot),
+    readRuntimePackageManifest(projectRoot)
+  ]);
+  const deployments = await Promise.all(
+    Object.entries(runtime.deployments).map(
+      async ([deploymentId, declaration]) => {
+        const strategies2 = await Promise.all(
+          Object.entries(declaration.strategies).map(
+            ([strategyName, strategyDeclaration]) => resolveStrategyComposition({
+              strategyName,
+              declaration: strategyDeclaration,
+              deployment: declaration,
+              projectRoot,
+              packageManifest
+            })
+          )
+        );
+        const provider = (declaration.provider || declaration.connectorName).trim().toLowerCase();
+        return {
+          deploymentId,
+          deploymentCompositionId: computeDeploymentCompositionId({
+            deploymentId,
+            connectorName: declaration.connectorName.trim(),
+            provider,
+            accountId: declaration.accountId.trim(),
+            enabled: declaration.enabled ?? true,
+            ...declaration.assetClasses ? { assetClasses: declaration.assetClasses } : {},
+            strategies: strategies2.map((strategy) => ({
+              strategyName: strategy.strategyName,
+              strategyRevision: strategy.strategyRevision,
+              enabled: strategy.enabled,
+              ...strategy.selection ? { selection: strategy.selection } : {}
+            }))
+          }),
+          declaration,
+          strategies: strategies2
+        };
+      }
+    )
+  );
+  return {
+    deployments: deployments.sort(
+      (left, right) => left.deploymentId.localeCompare(right.deploymentId)
+    )
+  };
+};
+var toRuntimeDeployment = ({
+  composition,
   controls
 }) => {
+  const { declaration, deploymentId } = composition;
   const deploymentEnabled = declaration.enabled ?? true;
   return {
-    id,
-    label: declaration.label?.trim() || id,
+    id: deploymentId,
+    deploymentCompositionId: composition.deploymentCompositionId,
+    label: declaration.label?.trim() || deploymentId,
     connectorName: declaration.connectorName.trim(),
     provider: (declaration.provider || declaration.connectorName).trim().toLowerCase(),
     accountId: declaration.accountId.trim(),
     enabled: deploymentEnabled,
-    strategies: Object.entries(declaration.strategies).map(
-      ([strategyName, strategy]) => {
-        const selection = resolveStrategySelection({
-          deployment: declaration,
-          strategy
-        });
-        return {
-          strategyName,
-          version: strategy.version,
-          enabled: strategy.enabled,
-          controlState: deploymentEnabled && strategy.enabled && !controls.deployments[id]?.[strategyName]?.entriesPaused ? "active" : "entries_paused",
-          ...selection ? { selection } : {}
-        };
-      }
-    ),
+    strategies: composition.strategies.map((strategy) => ({
+      strategyName: strategy.strategyName,
+      strategyRevision: strategy.strategyRevision,
+      enabled: strategy.enabled,
+      controlState: deploymentEnabled && strategy.enabled && !controls.deployments[deploymentId]?.[strategy.strategyName]?.entriesPaused ? "active" : "entries_paused",
+      ...strategy.selection ? { selection: strategy.selection } : {}
+    })),
     ...declaration.assetClasses ? { assetClasses: declaration.assetClasses } : {},
     ...declaration.tickers ? { tickers: declaration.tickers } : {}
   };
 };
-var loadRuntimeDeclaration = async (projectRoot) => {
-  const projectConfig = await loadTradejsConfig(projectRoot);
-  if (!projectConfig.runtime) {
-    throw new Error("Runtime declaration is required in tradejs.config.ts");
-  }
-  return verifyRuntimeDeclaration(projectConfig.runtime);
-};
 var listRuntimeDeployments = async ({
   userName,
   projectRoot
 }) => {
-  const [runtime, controls] = await Promise.all([
-    loadRuntimeDeclaration(projectRoot),
+  const [composition, controls] = await Promise.all([
+    resolveRuntimeComposition({ projectRoot }),
     (0, import_runtimeControls.getRuntimeControls)(userName)
   ]);
-  return Object.entries(runtime.deployments).map(
-    ([id, declaration]) => toRuntimeDeployment({ id, declaration, controls })
+  return composition.deployments.map(
+    (deploymentComposition) => toRuntimeDeployment({ composition: deploymentComposition, controls })
   ).sort((left, right) => left.label.localeCompare(right.label));
 };
 var getRuntimeDeployment = async ({
@@ -6440,87 +6698,37 @@ var loadResolvedRuntimeStrategies = async ({
   accountId,
   interval
 }) => {
-  const [runtime, controls, packageManifest] = await Promise.all([
-    loadRuntimeDeclaration(projectRoot),
-    (0, import_runtimeControls.getRuntimeControls)(userName),
-    readPackageManifest(projectRoot)
+  const [composition, controls] = await Promise.all([
+    resolveRuntimeComposition({ projectRoot }),
+    (0, import_runtimeControls.getRuntimeControls)(userName)
   ]);
-  const declaration = runtime.deployments[deploymentId];
-  if (!declaration) {
+  const deploymentComposition = composition.deployments.find(
+    (candidate) => candidate.deploymentId === deploymentId
+  );
+  if (!deploymentComposition) {
     throw new Error(`Runtime deployment not found: ${deploymentId}`);
   }
   const deployment = toRuntimeDeployment({
-    id: deploymentId,
-    declaration,
+    composition: deploymentComposition,
     controls
   });
   const strategies2 = await Promise.all(
-    Object.entries(declaration.strategies).map(
-      async ([strategyName, strategyDeclaration]) => {
-        const strategyCreator = await getStrategyCreator(
-          strategyName,
-          projectRoot
-        );
-        if (!strategyCreator) {
-          throw new Error(`Unknown strategy: ${strategyName}`);
-        }
-        const pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
-        const strategyPackage = await resolveStrategyPackageName({
-          pluginSource,
-          projectRoot
-        });
-        const [strategyPackageVersion, runtimePackageVersion] = await Promise.all([
-          resolveInstalledPackageVersion(
-            projectRoot,
-            strategyPackage,
-            packageManifest
-          ),
-          resolveInstalledPackageVersion(
-            projectRoot,
-            "@tradejs/node",
-            packageManifest
-          )
-        ]);
-        if (!strategyPackage || !strategyPackageVersion) {
-          throw new Error(
-            `Installed strategy package not found: ${strategyName}`
-          );
-        }
-        if (!runtimePackageVersion) {
-          throw new Error("Installed @tradejs/node package version not found");
-        }
-        const strategyView = deployment.strategies.find(
-          (candidate) => candidate.strategyName === strategyName
-        );
-        const selection = resolveStrategySelection({
-          deployment: declaration,
-          strategy: strategyDeclaration
-        });
-        const strategyConfig = strategyDeclaration.config;
-        const strategyUniverse = strategyConfig.UNIVERSE;
-        const resolvedAccountId = await resolveAccountId({
-          userName,
-          deployment,
-          universe: strategyUniverse
-        });
-        return {
-          strategyName,
-          version: strategyDeclaration.version,
-          enabled: strategyDeclaration.enabled,
-          controlState: strategyView?.controlState ?? "entries_paused",
-          interval: String(strategyConfig.INTERVAL),
-          universe: strategyUniverse,
-          accountId: resolvedAccountId,
-          strategyPackage,
-          strategyPackageVersion,
-          runtimePackageVersion,
-          strategyCreator,
-          sourceStrategyConfig: strategyConfig,
-          strategyConfig,
-          ...selection ? { selection } : {}
-        };
-      }
-    )
+    deploymentComposition.strategies.map(async (strategy) => {
+      const strategyView = deployment.strategies.find(
+        (candidate) => candidate.strategyName === strategy.strategyName
+      );
+      const resolvedAccountId = await resolveAccountId({
+        userName,
+        deployment,
+        universe: strategy.universe
+      });
+      return {
+        ...strategy,
+        deploymentCompositionId: deploymentComposition.deploymentCompositionId,
+        accountId: resolvedAccountId,
+        controlState: strategyView?.controlState ?? "entries_paused"
+      };
+    })
   );
   const filtered = strategies2.filter(
     (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
@@ -6539,31 +6747,55 @@ var getRuntimeStrategyPackageMetadata = async ({
   strategyName,
   projectRoot
 }) => {
-  const packageManifest = await readPackageManifest(projectRoot);
-  const pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
-  const strategyPackage = await resolveStrategyPackageName({
-    pluginSource,
+  const [packageManifest, pluginSource] = await Promise.all([
+    readRuntimePackageManifest(projectRoot),
+    getStrategyPluginSource(strategyName, projectRoot)
+  ]);
+  const strategyPackage = await resolveStrategyPackage({
+    pluginSource: pluginSource ?? null,
     projectRoot
   });
-  return {
-    strategyPackage,
-    strategyPackageVersion: await resolveInstalledPackageVersion(
+  if (!strategyPackage) {
+    throw new Error(`Installed strategy package not found: ${strategyName}`);
+  }
+  const [
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion
+  ] = await Promise.all([
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: strategyPackage.name,
+      projectPackage: strategyPackage.projectPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedStrategyDependencyVersions({
       projectRoot,
       strategyPackage,
-      packageManifest
-    ),
-    runtimePackageVersion: await resolveInstalledPackageVersion(
+      manifest: packageManifest
+    }),
+    resolveVerifiedPackageVersion({
       projectRoot,
-      "@tradejs/node",
-      packageManifest
-    )
+      packageName: "@tradejs/node",
+      manifest: packageManifest
+    })
+  ]);
+  return {
+    strategyPackage: strategyPackage.name,
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion
   };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RUNTIME_PACKAGE_MANIFEST_SCHEMA,
+  computeDeploymentCompositionId,
+  computeStrategyRevision,
   getRuntimeDeployment,
   getRuntimeStrategyPackageMetadata,
   listRuntimeDeployments,
   loadResolvedRuntimeStrategies,
+  resolveRuntimeComposition,
   verifyRuntimeDeclaration
 });