@tradejs/node 3.1.8-beta.206 → 3.1.8-beta.210

package/dist/runtimeDashboard.js

@@ -34,10 +34,8 @@ __export(runtimeDashboard_exports, {
 });
 module.exports = __toCommonJS(runtimeDashboard_exports);
 var import_time3 = require("@tradejs/core/time");
-var import_logger5 = require("@tradejs/infra/logger");
-var import_tradingAccounts2 = require("@tradejs/infra/tradingAccounts");
-var import_runtimeDeployments = require("@tradejs/infra/runtimeDeployments");
-var import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
+var import_logger6 = require("@tradejs/infra/logger");
+var import_tradingAccounts3 = require("@tradejs/infra/tradingAccounts");
 var import_redis2 = require("@tradejs/infra/redis");
 
 // src/connectorsRegistry.ts
@@ -78,17 +76,19 @@ var normalizeConfig = (rawConfig) => {
     return {};
   }
   const config = rawConfig;
-  const strategies = Array.isArray(config.strategies) ? config.strategies.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const strategies2 = Array.isArray(config.strategies) ? config.strategies.map((value) => String(value || "").trim()).filter(Boolean) : [];
   const indicators = Array.isArray(config.indicators) ? config.indicators.map((value) => String(value || "").trim()).filter(Boolean) : [];
   const connectors = Array.isArray(config.connectors) ? config.connectors.map((value) => String(value || "").trim()).filter(Boolean) : [];
   const hooks = (0, import_config.normalizeTradejsConfigHooks)(
     config.hooks
   );
+  const runtime = config.runtime && typeof config.runtime === "object" && !Array.isArray(config.runtime) ? config.runtime : void 0;
   return {
-    strategies,
+    strategies: strategies2,
     indicators,
     connectors,
-    ...hooks ? { hooks } : {}
+    ...hooks ? { hooks } : {},
+    ...runtime ? { runtime } : {}
   };
 };
 var getNodeCreateRequire = () => {
@@ -835,210 +835,6 @@ var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
 // src/runtimeDashboard.ts
 var import_runtimeTrades3 = require("@tradejs/core/runtimeTrades");
 
-// src/strategyEvidenceTimeline.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
-var DEFAULT_MARKER_DIRECTORY = "data/strategy-release/markers";
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-var strategyEvidenceTimelineSelectorKey = (selector) => [
-  selector.strategy,
-  selector.releaseVersion ?? "",
-  selector.compositionId ?? "",
-  selector.gitSha ?? "",
-  selector.gateFingerprint ?? "",
-  selector.configFingerprint ?? "",
-  selector.contextFingerprint ?? "",
-  selector.requireCompleteLineage ? "exact" : "partial"
-].join(":");
-var discoverJsonFiles = async (rootDir) => {
-  const files = [];
-  const visit = async (directory, depth) => {
-    if (depth > 12) return;
-    let entries;
-    try {
-      entries = await import_promises.default.readdir(directory, { withFileTypes: true });
-    } catch (error) {
-      if (error.code === "ENOENT") return;
-      throw error;
-    }
-    await Promise.all(
-      entries.map(async (entry) => {
-        if (entry.name.startsWith(".") || entry.name.includes(".tmp-")) return;
-        const entryPath = import_node_path.default.join(directory, entry.name);
-        if (entry.isDirectory()) {
-          await visit(entryPath, depth + 1);
-        } else if (entry.isFile() && entry.name.endsWith(".json")) {
-          files.push(entryPath);
-        }
-      })
-    );
-  };
-  await visit(rootDir, 0);
-  return files.sort();
-};
-var inferMatchingStrategies = ({
-  filePath,
-  rootDir,
-  parsed,
-  strategies
-}) => {
-  const payload = asRecord(asRecord(parsed)?.payload);
-  const declaredStrategy = isNonEmptyString(payload?.strategy) ? payload.strategy : null;
-  const directoryStrategy = import_node_path.default.relative(rootDir, filePath).split(import_node_path.default.sep)[0];
-  return strategies.filter(
-    (strategy) => strategy === declaredStrategy || directoryStrategy === (0, import_strategyReleaseEvidence.safeStrategyEvidenceSegment)(strategy)
-  );
-};
-var missingTimeline = () => ({
-  status: "missing",
-  observedFrom: null,
-  markers: []
-});
-var notAttachedTimeline = () => ({
-  status: "not_attached",
-  observedFrom: null,
-  markers: []
-});
-var invalidTimeline = () => ({
-  status: "invalid",
-  observedFrom: null,
-  markers: []
-});
-var loadStrategyEvidenceTimelines = async ({
-  projectRoot,
-  markerDir,
-  selectors: requestedSelectors,
-  startTime,
-  endTime
-}) => {
-  const selectors = [...requestedSelectors].filter((selector) => selector.strategy.trim().length > 0).sort(
-    (left, right) => strategyEvidenceTimelineSelectorKey(left).localeCompare(
-      strategyEvidenceTimelineSelectorKey(right)
-    )
-  );
-  const strategies = [...new Set(selectors.map(({ strategy }) => strategy))];
-  const timelines = new Map(
-    selectors.map((selector) => [
-      strategyEvidenceTimelineSelectorKey(selector),
-      selector.releaseVersion ? notAttachedTimeline() : missingTimeline()
-    ])
-  );
-  if (!selectors.length) return timelines;
-  const configuredDir = markerDir?.trim() || DEFAULT_MARKER_DIRECTORY;
-  const rootDir = import_node_path.default.isAbsolute(configuredDir) ? configuredDir : import_node_path.default.resolve(projectRoot, configuredDir);
-  let files;
-  try {
-    files = await discoverJsonFiles(rootDir);
-  } catch {
-    for (const selector of selectors) {
-      timelines.set(
-        strategyEvidenceTimelineSelectorKey(selector),
-        invalidTimeline()
-      );
-    }
-    return timelines;
-  }
-  const envelopesByStrategy = /* @__PURE__ */ new Map();
-  const invalidStrategies = /* @__PURE__ */ new Set();
-  for (const filePath of files) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(await import_promises.default.readFile(filePath, "utf8"));
-    } catch {
-      for (const strategy of inferMatchingStrategies({
-        filePath,
-        rootDir,
-        parsed,
-        strategies
-      })) {
-        invalidStrategies.add(strategy);
-      }
-      continue;
-    }
-    const matchingStrategies = inferMatchingStrategies({
-      filePath,
-      rootDir,
-      parsed,
-      strategies
-    });
-    if (!matchingStrategies.length) continue;
-    try {
-      const envelope = (0, import_strategyReleaseEvidence.verifyStrategyEvidenceMarkerEnvelope)(parsed);
-      for (const strategy of matchingStrategies) {
-        if (strategy !== envelope.payload.strategy) {
-          invalidStrategies.add(strategy);
-        }
-      }
-      if (!strategies.includes(envelope.payload.strategy)) {
-        continue;
-      }
-      const envelopes = envelopesByStrategy.get(envelope.payload.strategy) ?? [];
-      envelopes.push(envelope);
-      envelopesByStrategy.set(envelope.payload.strategy, envelopes);
-    } catch {
-      for (const strategy of matchingStrategies) {
-        invalidStrategies.add(strategy);
-      }
-    }
-  }
-  for (const selector of selectors) {
-    const strategy = selector.strategy;
-    const selectorKey = strategyEvidenceTimelineSelectorKey(selector);
-    if (invalidStrategies.has(strategy)) {
-      timelines.set(selectorKey, invalidTimeline());
-      continue;
-    }
-    const envelopes = envelopesByStrategy.get(strategy) ?? [];
-    if (!envelopes.length) continue;
-    const hasCompleteSelector = selector.releaseVersion != null || Boolean(selector.compositionId) && Boolean(selector.gitSha) && Boolean(selector.gateFingerprint) && Boolean(selector.configFingerprint) && Boolean(selector.contextFingerprint);
-    if (selector.requireCompleteLineage && !hasCompleteSelector) continue;
-    const markersById = /* @__PURE__ */ new Map();
-    let hasConflict = false;
-    for (const envelope of envelopes) {
-      for (const marker of envelope.payload.markers) {
-        const existing = markersById.get(marker.id);
-        if (existing && (0, import_strategyReleaseEvidence.canonicalStrategyEvidenceJson)(existing) !== (0, import_strategyReleaseEvidence.canonicalStrategyEvidenceJson)(marker)) {
-          hasConflict = true;
-          break;
-        }
-        markersById.set(marker.id, marker);
-      }
-      if (hasConflict) break;
-    }
-    if (hasConflict) {
-      timelines.set(selectorKey, invalidTimeline());
-      continue;
-    }
-    const matchingMarkers = [...markersById.values()].filter(
-      (marker) => (!selector.compositionId || marker.compositionId === selector.compositionId) && (!selector.releaseVersion || marker.releaseVersion === selector.releaseVersion) && (!selector.gitSha || marker.gitSha === selector.gitSha) && (!selector.gateFingerprint || marker.gateFingerprint === selector.gateFingerprint) && (!selector.configFingerprint || marker.configFingerprint === selector.configFingerprint) && (!selector.contextFingerprint || marker.contextFingerprint === selector.contextFingerprint) && marker.timestamp >= startTime && marker.timestamp < endTime
-    ).sort(
-      (left, right) => left.timestamp - right.timestamp || left.type.localeCompare(right.type) || left.id.localeCompare(right.id)
-    );
-    let lastLossValue;
-    let hasLastLossValue = false;
-    const markers = matchingMarkers.filter((marker) => {
-      if (marker.type !== "L") return true;
-      if (hasLastLossValue && marker.maxLossValue === lastLossValue) {
-        return false;
-      }
-      hasLastLossValue = true;
-      lastLossValue = marker.maxLossValue;
-      return true;
-    });
-    if (!markers.length && (selector.compositionId || selector.releaseVersion || selector.gitSha || selector.gateFingerprint || selector.configFingerprint || selector.contextFingerprint)) {
-      continue;
-    }
-    timelines.set(selectorKey, {
-      status: "verified",
-      observedFrom: markers.length ? Math.min(...markers.map((marker) => marker.timestamp)) : Math.min(...envelopes.map((envelope) => envelope.payload.createdAt)),
-      markers
-    });
-  }
-  return timelines;
-};
-
 // src/runtimeTradeSync.ts
 var import_constants2 = require("@tradejs/core/constants");
 var import_time2 = require("@tradejs/core/time");
@@ -1532,6 +1328,499 @@ var syncRuntimeTrades = async ({
   return syncedTrades;
 };
 
+// src/runtimeStrategies.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+var import_runtimeControls = require("@tradejs/infra/runtimeControls");
+var import_tradingAccounts2 = require("@tradejs/infra/tradingAccounts");
+
+// src/strategy/manifests.ts
+var import_indicators = require("@tradejs/core/indicators");
+var import_logger5 = require("@tradejs/infra/logger");
+var SHARED_STRATEGY_REGISTRY_KEY = "__tradejsNodeSharedStrategyRegistryV1__";
+var sharedRegistryScope = globalThis;
+var sharedStrategyRegistry = sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] ?? (sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] = {
+  registryStateByProjectRoot: /* @__PURE__ */ new Map()
+});
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot2 = sharedStrategyRegistry.registryStateByProjectRoot;
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot2.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot2.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
+var toUniqueModules2 = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
+  return {
+    strategyModules: toUniqueModules2(config.strategies),
+    indicatorModules: toUniqueModules2(config.indicators)
+  };
+};
+var extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
+  }
+  const candidate = moduleExport;
+  if (Array.isArray(candidate[key])) {
+    return candidate[key];
+  }
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport[key])) {
+    return defaultExport[key];
+  }
+  return null;
+};
+var extractStrategyPluginDefinition = (moduleExport) => {
+  const strategyEntries = extractModuleEntries(
+    moduleExport,
+    "strategyEntries"
+  );
+  return strategyEntries ? { strategyEntries } : null;
+};
+var extractIndicatorPluginDefinition = (moduleExport) => {
+  const indicatorEntries = extractModuleEntries(
+    moduleExport,
+    "indicatorEntries"
+  );
+  return indicatorEntries ? { indicatorEntries } : null;
+};
+var registerEntries2 = (entries, source, state) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest?.name;
+    if (!strategyName) {
+      import_logger5.logger.warn("Skip strategy entry without name from %s", source);
+      continue;
+    }
+    if (state.strategyCreators.has(strategyName)) {
+      import_logger5.logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
+    materializeStrategyCreator(strategyName, state);
+  }
+};
+var materializeStrategyCreator = (strategyName, state) => {
+  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
+    return;
+  }
+  const entry = state.strategyEntriesMap.get(strategyName);
+  if (!entry) return;
+  state.strategyCreators.set(
+    strategyName,
+    sharedStrategyRegistry.strategyRuntimeFactory({
+      strategyName,
+      defaults: entry.defaults,
+      createCore: entry.createCore,
+      manifest: entry.manifest,
+      detectorKey: entry.detectorKey,
+      detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+      resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
+    })
+  );
+};
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+    state.pluginsLoadPromise = (async () => {
+      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+      const strategySet = new Set(strategyModules);
+      const indicatorSet = new Set(indicatorModules);
+      const pluginModuleNames = [
+        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+      ];
+      if (!pluginModuleNames.length) {
+        return;
+      }
+      for (const moduleName of pluginModuleNames) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importStrategyPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              import_logger5.logger.warn(
+                'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerEntries2(
+                pluginDefinition.strategyEntries,
+                moduleName,
+                state
+              );
+            }
+          }
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              import_logger5.logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              (0, import_indicators.registerIndicatorEntries)(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            import_logger5.logger.warn(
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
+              moduleName
+            );
+          }
+        } catch (error) {
+          import_logger5.logger.warn(
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
+};
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategySourcesMap.get(name);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
+
+// src/runtimeStrategies.ts
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var RUNTIME_KEYS = /* @__PURE__ */ new Set(["deployments"]);
+var DEPLOYMENT_KEYS = /* @__PURE__ */ new Set([
+  "label",
+  "connectorName",
+  "provider",
+  "accountId",
+  "enabled",
+  "strategies",
+  "assetClasses",
+  "tickers"
+]);
+var STRATEGY_KEYS = /* @__PURE__ */ new Set(["version", "enabled", "config"]);
+var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "ACCOUNT_ID",
+  "DEPLOYMENT_ID",
+  "CONNECTOR_NAME",
+  "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 {
+    }
+  }
+  return { packages: {} };
+};
+var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest) => {
+  if (!packageName || packageName === "runtime") return null;
+  const manifestVersion = manifest.packages?.[packageName];
+  if (manifestVersion) return manifestVersion;
+  try {
+    const packageJsonPath = import_node_path.default.join(
+      projectRoot,
+      "node_modules",
+      ...packageName.split("/"),
+      "package.json"
+    );
+    const packageJson = JSON.parse(await (0, import_promises.readFile)(packageJsonPath, "utf8"));
+    return packageJson.version ?? null;
+  } catch {
+    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 verifyStringArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+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) {
+    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" || !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(
+        `Invalid runtime strategy declaration: ${deploymentId}/${strategyName}`
+      );
+    }
+  }
+  return value;
+};
+var verifyRuntimeDeclaration = (value) => {
+  if (!isRecord(value) || Object.keys(value).some((key) => !RUNTIME_KEYS.has(key)) || !isRecord(value.deployments) || !Object.keys(value.deployments).length) {
+    throw new Error("Invalid runtime declaration");
+  }
+  for (const [deploymentId, deployment] of Object.entries(value.deployments)) {
+    verifyDeploymentDeclaration(deploymentId, deployment);
+  }
+  return value;
+};
+var toRuntimeDeployment = ({
+  id,
+  declaration,
+  controls
+}) => {
+  const deploymentEnabled = declaration.enabled ?? true;
+  return {
+    id,
+    label: declaration.label?.trim() || id,
+    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]) => ({
+        strategyName,
+        version: strategy.version,
+        enabled: strategy.enabled,
+        controlState: deploymentEnabled && strategy.enabled && !controls.deployments[id]?.[strategyName]?.entriesPaused ? "active" : "entries_paused"
+      })
+    ),
+    ...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),
+    (0, import_runtimeControls.getRuntimeControls)(userName)
+  ]);
+  return Object.entries(runtime.deployments).map(
+    ([id, declaration]) => toRuntimeDeployment({ id, declaration, controls })
+  ).sort((left, right) => left.label.localeCompare(right.label));
+};
+var resolveAccountId = async ({
+  userName,
+  deployment,
+  universe
+}) => {
+  const account = await (0, import_tradingAccounts2.resolveTradingAccount)({
+    userName,
+    accountId: deployment.accountId,
+    provider: deployment.provider,
+    universe
+  });
+  if (!account) {
+    throw new Error(`Trading account not found: ${deployment.accountId}`);
+  }
+  return account.id;
+};
+var loadResolvedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deploymentId,
+  universe,
+  accountId,
+  interval
+}) => {
+  const [runtime, controls, packageManifest] = await Promise.all([
+    loadRuntimeDeclaration(projectRoot),
+    (0, import_runtimeControls.getRuntimeControls)(userName),
+    readPackageManifest(projectRoot)
+  ]);
+  const declaration = runtime.deployments[deploymentId];
+  if (!declaration) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  const deployment = toRuntimeDeployment({
+    id: deploymentId,
+    declaration,
+    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 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
+        };
+      }
+    )
+  );
+  const filtered = strategies2.filter(
+    (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
+  );
+  const identities = /* @__PURE__ */ new Set();
+  for (const candidate of filtered) {
+    const identity = `${candidate.strategyName}:${candidate.accountId ?? "default"}`;
+    if (identities.has(identity)) {
+      throw new Error(`Runtime strategy conflict: ${identity}`);
+    }
+    identities.add(identity);
+  }
+  return filtered;
+};
+
 // src/runtimeDashboard.ts
 var DEFAULT_PROVIDER = "bybit";
 var DEFAULT_HOURS = 168;
@@ -1550,7 +1839,7 @@ var resolveConnectorCreatorByProvider = async (provider, projectRoot) => await g
 var resolveConnectorAccountId = async ({
   userName,
   provider
-}) => (await (0, import_tradingAccounts2.resolveTradingAccount)({
+}) => (await (0, import_tradingAccounts3.resolveTradingAccount)({
   userName,
   provider,
   universe: "crypto"
@@ -1616,7 +1905,7 @@ var loadExchangeRange = async ({
   } catch (error) {
     const message = error?.message || String(error);
     errors?.push(`${label}: ${message}`);
-    import_logger5.logger.warn("strategies runtime: %s failed: %s", label, message);
+    import_logger6.logger.warn("strategies runtime: %s failed: %s", label, message);
     return [];
   }
 };
@@ -1656,7 +1945,7 @@ var loadClosedPnlRows = async ({
   } catch (error) {
     const message = error?.message || String(error);
     errors?.push(`getClosedPnl: ${message}`);
-    import_logger5.logger.warn("strategies runtime: getClosedPnl failed: %s", message);
+    import_logger6.logger.warn("strategies runtime: getClosedPnl failed: %s", message);
     return [];
   }
 };
@@ -1689,7 +1978,7 @@ var loadExchangeEntryRows = async ({
   } catch (error) {
     const message = error?.message || String(error);
     errors?.push(`getEntryExecutions: ${message}`);
-    import_logger5.logger.warn("strategies runtime: getEntryExecutions failed: %s", message);
+    import_logger6.logger.warn("strategies runtime: getEntryExecutions failed: %s", message);
     return [];
   }
 };
@@ -1705,7 +1994,7 @@ var loadOpenPositions = async (connector, errors) => {
   } catch (error) {
     const message = error?.message || String(error);
     errors?.push(`getOpenPositionPnl: ${message}`);
-    import_logger5.logger.warn("strategies runtime: getOpenPositionPnl failed: %s", message);
+    import_logger6.logger.warn("strategies runtime: getOpenPositionPnl failed: %s", message);
     return { positions: [], reliable: false };
   }
 };
@@ -1762,8 +2051,8 @@ var loadRuntimeDashboard = async ({
       errors: exchangeErrors
     }),
     loadOpenPositions(connector, exchangeErrors),
-    (0, import_runtimeDeployments.listRuntimeDeployments)(userName),
-    (0, import_tradingAccounts2.listTradingAccounts)(userName)
+    listRuntimeDeployments({ userName, projectRoot }),
+    (0, import_tradingAccounts3.listTradingAccounts)(userName)
   ]);
   const relevantTrades = (0, import_runtimeTrades3.selectTradesForWindow)(
     runtimeTrades,
@@ -1807,9 +2096,23 @@ var loadRuntimeDashboard = async ({
   const accountsById = new Map(
     tradingAccounts.map((account) => [account.id, account])
   );
+  const resolvedStrategiesByDeployment = new Map(
+    await Promise.all(
+      runtimeDeployments.map(
+        async (deployment) => [
+          deployment.id,
+          await loadResolvedRuntimeStrategies({
+            userName,
+            projectRoot,
+            deploymentId: deployment.id
+          })
+        ]
+      )
+    )
+  );
   const runtimeIdentityKey = (trade) => (0, import_runtimeTrades3.buildRuntimeStrategyIdentityKey)({
     strategyName: trade.strategy,
-    configId: trade.runtimeReleaseVersion ? `v${trade.runtimeReleaseVersion}` : void 0,
+    configId: trade.runtimeVersion ? `v${trade.runtimeVersion}` : void 0,
     universe: trade.universe,
     accountId: trade.accountId,
     deploymentId: trade.deploymentId,
@@ -1817,42 +2120,34 @@ var loadRuntimeDashboard = async ({
   });
   const identityByKey = /* @__PURE__ */ new Map();
   for (const deployment of runtimeDeployments) {
-    for (const deploymentStrategy of deployment.strategies) {
-      const release = await (0, import_runtimeStrategyReleases.getRuntimeStrategyRelease)(
-        userName,
-        deploymentStrategy.strategyName,
-        deploymentStrategy.releaseVersion
-      );
-      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;
+    for (const resolvedStrategy of resolvedStrategiesByDeployment.get(
+      deployment.id
+    ) ?? []) {
+      const strategyUniverse = resolvedStrategy.universe;
+      const strategyInterval = resolvedStrategy.interval;
+      const strategyConfigId = `v${resolvedStrategy.version}`;
+      const strategyPolicyProfileId = typeof resolvedStrategy.strategyConfig.POLICY_PROFILE_ID === "string" ? resolvedStrategy.strategyConfig.POLICY_PROFILE_ID : void 0;
       const runtimeKey = (0, import_runtimeTrades3.buildRuntimeStrategyIdentityKey)({
-        strategyName: deploymentStrategy.strategyName,
-        configId: releaseConfigId,
-        universe: releaseUniverse,
+        strategyName: resolvedStrategy.strategyName,
+        configId: strategyConfigId,
+        universe: strategyUniverse,
         accountId: deployment.accountId,
         deploymentId: deployment.id,
-        policyProfileId: releasePolicyProfileId
+        policyProfileId: strategyPolicyProfileId
       });
       identityByKey.set(runtimeKey, {
-        strategyName: deploymentStrategy.strategyName,
-        configId: releaseConfigId,
-        releaseVersion: deploymentStrategy.releaseVersion,
-        controlState: deploymentStrategy.controlState,
-        interval: releaseInterval,
-        universe: releaseUniverse,
+        strategyName: resolvedStrategy.strategyName,
+        configId: strategyConfigId,
+        version: resolvedStrategy.version,
+        controlState: resolvedStrategy.controlState,
+        interval: strategyInterval,
+        universe: strategyUniverse,
         accountId: deployment.accountId,
         accountLabel: accountsById.get(deployment.accountId)?.label,
         deploymentId: deployment.id,
-        policyProfileId: releasePolicyProfileId,
-        enabled: deployment.enabled && deploymentStrategy.controlState !== "entries_paused",
-        config: release.config,
+        policyProfileId: strategyPolicyProfileId,
+        enabled: resolvedStrategy.controlState !== "entries_paused",
+        config: resolvedStrategy.strategyConfig,
         connected: deployment.enabled
       });
     }
@@ -1862,8 +2157,8 @@ var loadRuntimeDashboard = async ({
     const key = runtimeIdentityKey(trade);
     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;
+    const version = trade.runtimeVersion ?? (trade.runtimeLineage?.schemaVersion === 2 ? trade.runtimeLineage.version : void 0);
+    if (version !== configuredIdentity.version) continue;
     identityByKey.set(key, {
       ...configuredIdentity,
       interval: String(
@@ -1871,18 +2166,7 @@ var loadRuntimeDashboard = async ({
       )
     });
   }
-  const evidenceTimelines = await loadStrategyEvidenceTimelines({
-    projectRoot,
-    markerDir: process.env.STRATEGY_RELEASE_MARKER_DIR,
-    selectors: [...identityByKey.values()].map((identity) => ({
-      strategy: identity.strategyName,
-      releaseVersion: identity.releaseVersion,
-      requireCompleteLineage: true
-    })),
-    startTime,
-    endTime
-  });
-  const strategies = await Promise.all(
+  const strategies2 = await Promise.all(
     [...identityByKey.entries()].map(async ([runtimeKey, identity]) => {
       const { strategyName } = identity;
       const strategyTrades = accountScopedTrades.filter((trade) => runtimeIdentityKey(trade) === runtimeKey).sort((left, right) => right.entryTimestamp - left.entryTimestamp);
@@ -1901,7 +2185,7 @@ var loadRuntimeDashboard = async ({
         runtimeKey,
         strategyName,
         configId: identity.configId,
-        releaseVersion: identity.releaseVersion,
+        version: identity.version,
         controlState: identity.controlState,
         interval: identity.interval,
         universe: identity.universe,
@@ -1916,23 +2200,12 @@ var loadRuntimeDashboard = async ({
         stat: analytics.stat,
         summary: analytics.summary,
         orderLog: analytics.orderLog,
-        evidenceTimeline: evidenceTimelines.get(
-          strategyEvidenceTimelineSelectorKey({
-            strategy: strategyName,
-            releaseVersion: identity.releaseVersion,
-            requireCompleteLineage: true
-          })
-        ) ?? {
-          status: "not_attached",
-          observedFrom: null,
-          markers: []
-        },
         recentTrades: strategyTrades.slice(0, 8).map((trade) => (0, import_runtimeTrades3.toRuntimeTradeView)(trade, endTime)),
         orders
       };
     })
   );
-  strategies.sort((left, right) => {
+  strategies2.sort((left, right) => {
     if (left.stat.netProfit !== right.stat.netProfit) {
       return right.stat.netProfit - left.stat.netProfit;
     }
@@ -1953,7 +2226,7 @@ var loadRuntimeDashboard = async ({
       exchangeFallbackTrades: fallbackTrades.length,
       exchangeErrors: [...new Set(exchangeErrors)].sort()
     },
-    strategies
+    strategies: strategies2
   };
   return response;
 };