@tradejs/cli 3.1.8-beta.213 → 3.1.9-beta.214

package/dist/scripts/replayRunner.js

@@ -75,6 +75,57 @@ var import_connectors3 = require("@tradejs/node/connectors");
 var import_cli3 = require("@tradejs/node/cli");
 var import_constants = require("@tradejs/core/constants");
 var import_time2 = require("@tradejs/core/time");
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+
+// src/lib/runtimeStrategyBacktest.ts
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/runtimeRedis.ts
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
+var isRuntimeTradeRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
+};
+var loadRuntimeTrades = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
+  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
+  if (hasWindow) {
+    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+    const bucketTrades = (await Promise.all(
+      dayKeys.map(
+        (dayKey) => (0, import_redis.getHashJsonValues)(
+          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
+        )
+      )
+    )).flat();
+    const dedupedBucketTrades = /* @__PURE__ */ new Map();
+    for (const trade of bucketTrades) {
+      if (!isRuntimeTradeRecord(trade)) {
+        continue;
+      }
+      dedupedBucketTrades.set(trade.orderId, trade);
+    }
+    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+    if (windowedTrades.length > 0 || dayKeys.length === 0) {
+      return windowedTrades;
+    }
+  }
+  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
+  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
+    (key) => !key.startsWith(bucketPrefix)
+  );
+  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
 
 // src/lib/timeWindow.ts
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
@@ -178,95 +229,6 @@ var resolveTimeWindow = ({
   );
 };
 
-// src/lib/runtimeStrategyBacktest.ts
-var import_chalk = __toESM(require("chalk"));
-
-// src/lib/runtimeRedis.ts
-var import_redis = require("@tradejs/infra/redis");
-var import_time = require("@tradejs/core/time");
-var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
-var isRuntimeStrategyEnabled = (strategyConfig) => {
-  const enabled = strategyConfig.ENABLE;
-  return enabled !== false;
-};
-var isRuntimeTradeRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
-};
-var loadRuntimeTrades = async (userName, {
-  startTime,
-  endTime
-} = {}) => {
-  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
-  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
-  if (hasWindow) {
-    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
-    const bucketTrades = (await Promise.all(
-      dayKeys.map(
-        (dayKey) => (0, import_redis.getHashJsonValues)(
-          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
-        )
-      )
-    )).flat();
-    const dedupedBucketTrades = /* @__PURE__ */ new Map();
-    for (const trade of bucketTrades) {
-      if (!isRuntimeTradeRecord(trade)) {
-        continue;
-      }
-      dedupedBucketTrades.set(trade.orderId, trade);
-    }
-    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-    if (windowedTrades.length > 0 || dayKeys.length === 0) {
-      return windowedTrades;
-    }
-  }
-  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
-  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
-  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
-    (key) => !key.startsWith(bucketPrefix)
-  );
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-};
-
-// src/lib/runtimeStrategyBacktest.ts
-var BACKTEST_CLI_RUNTIME_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "ENV",
-  "INTERVAL",
-  "MAKE_ORDERS",
-  "CLOSE_OPPOSITE_POSITIONS",
-  "BACKTEST_PRICE_MODE",
-  "BACKTEST_ENTRY_DELAY_BARS"
-]);
-var toStrategyConfigGrid = (strategyConfig) => Object.fromEntries(
-  Object.entries(strategyConfig).filter(([key]) => !BACKTEST_CLI_RUNTIME_CONFIG_KEYS.has(key)).map(([key, value]) => [key, [value]])
-);
-var loadRuntimeStrategyBacktestConfigs = async (userName) => {
-  const configs = await (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName, {
-    onInvalidConfig: (key) => {
-      console.log(import_chalk.default.yellow(`Skip invalid runtime strategy config: ${key}`));
-    }
-  });
-  return configs.filter(({ configId }) => configId === "config").filter(({ strategyName, strategyConfig }) => {
-    const enabled = isRuntimeStrategyEnabled(strategyConfig);
-    if (!enabled) {
-      console.log(
-        import_chalk.default.yellow(
-          `Skip inactive runtime strategy config by ENABLE=false: ${strategyName}`
-        )
-      );
-    }
-    return enabled;
-  }).map(({ strategyName, strategyConfig }) => ({
-    strategyName,
-    strategyConfig,
-    backtestConfig: toStrategyConfigGrid(strategyConfig)
-  }));
-};
-
 // src/lib/marketData/historyPrepare.ts
 var import_chalk2 = __toESM(require("chalk"));
 var import_connectors = require("@tradejs/connectors");
@@ -540,17 +502,43 @@ var resolveRunConnectorName = async ({
   );
   return import_connectors3.DEFAULT_CONNECTOR_NAME;
 };
-var loadReplayStrategies = async (userName) => {
-  const runtimeStrategies = await loadRuntimeStrategyBacktestConfigs(userName);
-  if (!runtimeStrategies.length) {
+var loadDeploymentReplayStrategies = async ({
+  userName,
+  projectRoot,
+  deploymentId
+}) => {
+  const [deployment, runtimeStrategies] = await Promise.all([
+    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot, deploymentId }),
+    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot, deploymentId })
+  ]);
+  if (!deployment) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  const strategies = deployment.enabled ? runtimeStrategies.filter((strategy) => strategy.enabled).map(
+    ({
+      strategyName,
+      version,
+      strategyPackage,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      sourceStrategyConfig
+    }) => ({
+      strategyName,
+      version,
+      strategyPackage,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      strategyConfig: sourceStrategyConfig
+    })
+  ) : [];
+  if (!strategies.length) {
     console.log(
       import_chalk3.default.yellow(
-        `No active runtime strategy configs found by users:${userName}:strategies:*:config`
+        `No enabled strategies found in runtime deployment ${deploymentId}`
       )
     );
-    return [];
   }
-  return runtimeStrategies;
+  return { deployment, strategies };
 };
 var prepareRunEnvironment = async ({
   connector,
@@ -4307,6 +4295,11 @@ import_args.default.option(
   "runtimeEvidence",
   "Immutable runtime evidence JSON used for offline runtime comparison"
 );
+import_args.default.option(
+  "deployment",
+  "Git-owned runtime deployment used when runtime evidence is omitted",
+  "production"
+);
 import_args.default.option(["u", "updateOnly"], "Only update tickers history", false);
 import_args.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
 import_args.default.option(
@@ -4333,97 +4326,673 @@ var replayInterval = String(replayFlags.timeframe ?? 15);
 var replayUserName = String(replayFlags.user ?? "root");
 var replayProjectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var replayRuntimeEvidencePath = typeof replayFlags.runtimeEvidence === "string" && replayFlags.runtimeEvidence.trim() ? replayFlags.runtimeEvidence.trim() : null;
+var replayDeploymentId = String(
+  replayFlags.deployment ?? "production"
+).trim();
 var isReplayUpdateOnlyRun = Boolean(replayFlags.updateOnly);
 
-// src/lib/replay/support.ts
-var import_chalk8 = __toESM(require("chalk"));
+// src/lib/replay/runtimeEvidenceSource.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
 
-// src/lib/runtimeModeConfig.ts
-var buildRuntimeModeStrategyConfig = ({
-  strategyConfig,
-  env,
-  interval,
-  makeOrders,
-  recordRuntimeTrades,
-  aiReplayAnalyses
-}) => ({
-  ...strategyConfig,
-  ENV: env,
-  MAKE_ORDERS: makeOrders,
-  INTERVAL: strategyConfig.INTERVAL ?? interval,
-  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
-  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
-});
+// src/lib/runtimeLineage.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_types2 = require("@tradejs/types");
+var import_strategies3 = require("@tradejs/node/strategies");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
-// src/lib/replay/support.ts
-var REPLAY_RESULTS_BY_STRATEGY_HEADERS = [
-  import_chalk8.default.blue("STRATEGY"),
-  import_chalk8.default.yellow("TICKERS"),
-  import_chalk8.default.yellow("TRADE TICKERS"),
-  import_chalk8.default.cyan("ORDERS"),
-  import_chalk8.default.cyan("WIN/LOSS (%)"),
-  import_chalk8.default.cyan("PROFIT"),
-  import_chalk8.default.cyan("AVG TRADE")
-];
-var REPLAY_RUNTIME_COMPARISON_HEADERS = [
-  import_chalk8.default.blue("STRATEGY"),
-  import_chalk8.default.cyan("BT ENTRIES"),
-  import_chalk8.default.cyan("BT PNL"),
-  import_chalk8.default.yellow("RT TRADES"),
-  import_chalk8.default.yellow("RT PNL"),
-  import_chalk8.default.green("MATCHED"),
-  import_chalk8.default.red("ORDER FAILED"),
-  import_chalk8.default.yellow("RT ONLY"),
-  import_chalk8.default.magenta("BT ONLY"),
-  import_chalk8.default.red("UNMATCHED")
+// src/lib/strategyGateFingerprint.ts
+var import_node_crypto = require("crypto");
+var import_node_module = require("module");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var toPackageToken = (strategyName) => strategyName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var getStrategyPackageName = (strategyName) => strategyName === "TrendLine" || strategyName === "ReverseTrendLine" ? "@tradejs/strategy-trend-line" : `@tradejs/strategy-${toPackageToken(strategyName)}`;
+var gateFingerprintSpecifiers = (strategyName) => [
+  getStrategyPackageName(strategyName),
+  "@tradejs/strategy-kit/ai-gate",
+  "@tradejs/node/ai",
+  "@tradejs/core/strategies"
 ];
-var REPLAY_RESULTS_CONFIG = "replay";
-var REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS = 1;
-var REPLAY_RUNTIME_COMPARE_TOLERANCE_MS = REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS * 15 * 60 * 1e3;
-var formatReplayRuntimeCompareTolerance = () => `${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS} ${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS === 1 ? "bar" : "bars"}`;
-var getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly + row.backtestOnly;
-var buildReplayStrategyConfig = ({
-  strategyConfig,
-  interval
-}) => buildRuntimeModeStrategyConfig({
-  strategyConfig,
-  env: "PARITY",
-  interval,
-  makeOrders: true,
-  recordRuntimeTrades: false
-});
-var toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var compactReplayAdditionalIndicators = (additionalIndicators) => {
-  const additional = toRecord(additionalIndicators);
-  if (!additional) {
-    return void 0;
-  }
-  const compact = {};
-  if (additional.executionSlippage != null) {
-    compact.executionSlippage = additional.executionSlippage;
-  }
-  if (additional.marketContext != null) {
-    compact.marketContext = additional.marketContext;
-  }
-  const baseContext = toRecord(additional.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const execution = toRecord(relative?.execution);
-  if (execution) {
-    compact.baseContext = {
-      relative: {
-        execution
+var resolveStrategyGateFingerprint = async ({
+  projectRoot,
+  strategyName,
+  gitSha
+}) => {
+  const projectManifestPath = import_node_path.default.join(projectRoot, "package.json");
+  const projectExists = await import_promises.default.access(projectManifestPath).then(() => true).catch(() => false);
+  const requireFromProject = projectExists ? (0, import_node_module.createRequire)(projectManifestPath) : null;
+  const candidates = requireFromProject ? await Promise.all(
+    gateFingerprintSpecifiers(strategyName).map(async (specifier) => {
+      let resolvedPath;
+      try {
+        resolvedPath = requireFromProject.resolve(specifier);
+      } catch {
+        return null;
       }
-    };
-  }
-  return Object.keys(compact).length ? compact : void 0;
-};
-var compactReplaySignal = (signal) => {
-  if (!signal) {
-    return void 0;
-  }
-  return {
-    signalId: signal.signalId,
-    strategy: signal.strategy,
+      const content = await import_promises.default.readFile(resolvedPath).catch(() => null);
+      return content == null ? null : { specifier, content };
+    })
+  ) : [];
+  const sourceEntries = candidates.filter(
+    (entry) => entry != null
+  );
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.specifier);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  return {
+    gateFingerprint: hash.digest("hex").slice(0, 16),
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.specifier)
+  };
+};
+
+// src/lib/runtimeLineage.ts
+var RUNTIME_CONTEXT_ENV_KEYS = [
+  "AI_MODE",
+  "MIN_AI_QUALITY",
+  "INTERVAL",
+  "DERIVATIVES_CONTEXT_ENABLED",
+  "DERIVATIVES_CONTEXT_TARGET_ENABLED",
+  "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
+  "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
+  "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
+  "COINMARKETCAP_CONTEXT_ENABLED",
+  "COINMARKETCAP_CONTEXT_MAX_AGE_MS",
+  "COINMARKETCAP_CONTEXT_EXCHANGE_LIQUIDITY_ENABLED",
+  "COINMARKETCAP_CONTEXT_EXCHANGE_SLUGS",
+  "COINMARKETCAP_CONTEXT_FEAR_GREED_ENABLED",
+  "COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS",
+  "COINMARKETCAP_CONTEXT_BACKFILL_ENABLED",
+  "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
+  "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS",
+  "HYPERLIQUID_WHALE_CONTEXT_ENABLED",
+  "HYPERLIQUID_WHALE_BACKFILL_ENABLED",
+  "HYPERLIQUID_WHALE_MIN_COVERAGE_PCT",
+  "HYPERLIQUID_WHALE_CONCURRENCY",
+  "HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT"
+];
+var RUNTIME_CONTEXT_DATA_MODEL = {
+  derivativesSourceIntervals: "15m",
+  derivativesDerivedIntervals: "1h",
+  derivativesHourlyFallback: "stored-1h",
+  derivativesDataModelVersion: 2,
+  coinMarketCapAvailabilityModel: "closed-interval-all-daily",
+  coinMarketCapDataModelVersion: 3,
+  binanceBreadthUniverseModel: "fixed-versioned-top5-top10-top30-top50-top100",
+  binanceBreadthDataModelVersion: 2,
+  hyperliquidWhaleCanonicalInterval: "1m",
+  hyperliquidWhaleGateMinNotionalUsd: 5e4,
+  hyperliquidWhaleMinCoveragePct: 0.8,
+  hyperliquidWhaleDataModelVersion: import_types2.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+};
+var normalizeForStableJson = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeForStableJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+    );
+  }
+  return value;
+};
+var resolveRuntimeMaxLossValue = (config) => {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return null;
+  }
+  const strategyConfig = config.strategyConfig;
+  if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+    return null;
+  }
+  const maxLossValue = Number(
+    strategyConfig.MAX_LOSS_VALUE
+  );
+  return Number.isFinite(maxLossValue) ? maxLossValue : null;
+};
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var gitLineageCache = /* @__PURE__ */ new Map();
+var gateFingerprintCache = /* @__PURE__ */ new Map();
+var binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
+var snapshotFingerprintCache = /* @__PURE__ */ new Map();
+var resolveGitLineage = (projectRoot) => {
+  const cached = gitLineageCache.get(projectRoot);
+  if (cached) {
+    return cached;
+  }
+  const envSha = String(process.env.TRADEJS_GIT_SHA ?? "").trim();
+  if (envSha && envSha !== "unknown") {
+    const result = {
+      gitSha: envSha,
+      gitDirty: false
+    };
+    gitLineageCache.set(projectRoot, result);
+    return result;
+  }
+  try {
+    const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const status = (0, import_node_child_process.execFileSync)(
+      "git",
+      ["status", "--porcelain", "--untracked-files=normal"],
+      {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    const result = {
+      gitSha: gitSha || null,
+      gitDirty: status.length > 0
+    };
+    gitLineageCache.set(projectRoot, result);
+    return result;
+  } catch {
+    const result = {
+      gitSha: null,
+      gitDirty: null
+    };
+    gitLineageCache.set(projectRoot, result);
+    return result;
+  }
+};
+var readOptionalFile = async (filePath) => {
+  try {
+    return await import_promises2.default.readFile(filePath);
+  } catch {
+    return null;
+  }
+};
+var resolveBinanceBreadthFingerprint = async (projectRoot) => {
+  if (binanceBreadthFingerprintCache.has(projectRoot)) {
+    return binanceBreadthFingerprintCache.get(projectRoot) ?? null;
+  }
+  const content = await readOptionalFile(
+    import_node_path2.default.join(
+      projectRoot,
+      "packages/node/src/config/binanceBreadthUniverses.json"
+    )
+  );
+  let result = null;
+  if (content) {
+    try {
+      const parsed = JSON.parse(content.toString("utf8"));
+      result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
+    } catch {
+      result = null;
+    }
+  }
+  binanceBreadthFingerprintCache.set(projectRoot, result);
+  return result;
+};
+var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
+  const cacheKey = `${projectRoot}:${relativePath}`;
+  if (snapshotFingerprintCache.has(cacheKey)) {
+    return snapshotFingerprintCache.get(cacheKey) ?? null;
+  }
+  const content = await readOptionalFile(import_node_path2.default.join(projectRoot, relativePath));
+  let result = null;
+  if (content) {
+    try {
+      const parsed = JSON.parse(content.toString("utf8"));
+      result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
+    } catch {
+      result = null;
+    }
+  }
+  snapshotFingerprintCache.set(cacheKey, result);
+  return result;
+};
+var resolveRuntimeGateFingerprint = async ({
+  projectRoot,
+  strategyName,
+  gitSha
+}) => {
+  const cacheKey = `${projectRoot}:${strategyName}:${gitSha ?? "unknown"}`;
+  const cached = gateFingerprintCache.get(cacheKey);
+  if (cached) return cached;
+  const result = await resolveStrategyGateFingerprint({
+    projectRoot,
+    strategyName,
+    gitSha
+  });
+  gateFingerprintCache.set(cacheKey, result);
+  return result;
+};
+async function buildRuntimeLineage({
+  projectRoot,
+  strategyName,
+  compositionId,
+  version,
+  strategyPackageVersion,
+  runtimePackageVersion,
+  config,
+  runContext,
+  env = process.env
+}) {
+  if (version != null) {
+    if (!Number.isSafeInteger(version) || version <= 0) {
+      throw new Error(`Invalid runtime strategy version: ${version}`);
+    }
+    return {
+      schemaVersion: 2,
+      version,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      maxLossValue: resolveRuntimeMaxLossValue(config)
+    };
+  }
+  const git = resolveGitLineage(projectRoot);
+  const hyperliquidPerpUniverseFingerprint = typeof import_strategies3.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies3.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
+    projectRoot,
+    "packages/node/src/config/hyperliquidPerpUniverse.json"
+  );
+  const hyperliquidWhaleRegistryFingerprint = typeof import_strategies3.getHyperliquidWhaleRegistrySnapshot === "function" ? (0, import_strategies3.getHyperliquidWhaleRegistrySnapshot)().fingerprint : await resolveSnapshotFingerprint(
+    projectRoot,
+    "packages/node/src/config/hyperliquidWhales.json"
+  );
+  const context = {
+    ...Object.fromEntries(
+      RUNTIME_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
+    ),
+    ...RUNTIME_CONTEXT_DATA_MODEL,
+    binanceBreadthUniverseFingerprint: await resolveBinanceBreadthFingerprint(projectRoot),
+    hyperliquidPerpUniverseFingerprint,
+    hyperliquidWhaleRegistryFingerprint,
+    ...runContext
+  };
+  return {
+    schemaVersion: 1,
+    compositionId: compositionId?.trim() || null,
+    ...git,
+    gateFingerprint: (await resolveRuntimeGateFingerprint({
+      projectRoot,
+      strategyName,
+      gitSha: git.gitSha
+    })).gateFingerprint,
+    // Position risk is tracked separately so changing trade size does not
+    // masquerade as a change to the core + gate decision logic.
+    configFingerprint: (0, import_strategyReleaseEvidence.strategyLogicConfigFingerprint)(config),
+    contextFingerprint: fingerprintRuntimeValue(context),
+    maxLossValue: resolveRuntimeMaxLossValue(config)
+  };
+}
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? [
+  "v2",
+  lineage.version,
+  lineage.strategyPackageVersion ?? "strategy:unknown",
+  lineage.runtimePackageVersion ?? "runtime:unknown"
+].join(":") : [
+  lineage.schemaVersion,
+  lineage.compositionId ?? "unbound-composition",
+  lineage.gitSha ?? "unknown",
+  lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
+  lineage.gateFingerprint,
+  lineage.configFingerprint,
+  lineage.contextFingerprint
+].join(":");
+var runtimeLineagesMatch = (left, right) => left != null && right != null && runtimeLineageKey(left) === runtimeLineageKey(right);
+var runtimeLineagesComparable = (left, right) => runtimeLineagesMatch(left, right) && typeof left?.maxLossValue === "number" && Number.isFinite(left.maxLossValue) && typeof right?.maxLossValue === "number" && Number.isFinite(right.maxLossValue) && left.maxLossValue === right.maxLossValue;
+
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+  if (!isRecord(value) || value.schemaVersion !== 1 || !isNonEmptyString(value.id) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
+    throw new Error(
+      "Runtime evidence deployment snapshot is missing or invalid"
+    );
+  }
+  const strategies = value.strategies.map((candidate) => {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig)) {
+      throw new Error(
+        "Runtime evidence deployment strategy snapshot is invalid"
+      );
+    }
+    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+      throw new Error(
+        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+      );
+    }
+    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+      throw new Error(
+        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+      );
+    }
+    return candidate;
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (identities.has(strategy.strategyName)) {
+      throw new Error(
+        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+      );
+    }
+    identities.add(strategy.strategyName);
+  }
+  return {
+    ...value,
+    strategies
+  };
+};
+var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var runtimeDeploymentFromEvidence = (deployment) => ({
+  id: deployment.id,
+  label: deployment.label,
+  connectorName: deployment.connectorName,
+  provider: deployment.provider,
+  accountId: deployment.accountId,
+  enabled: deployment.enabled,
+  strategies: deployment.strategies.map(
+    ({ strategyName, version, enabled, controlState }) => ({
+      strategyName,
+      version,
+      enabled,
+      controlState
+    })
+  ),
+  ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+  ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+});
+
+// src/lib/replay/runtimeEvidenceSource.ts
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var unwrapRows = (value, field) => (Array.isArray(value) ? value : []).map((item) => {
+  const row = asRecord(item);
+  return asRecord(row?.[field]) ?? row;
+}).filter((item) => item != null);
+var assertRuntimeRowsMatchDeployment = ({
+  label,
+  rows,
+  deployment
+}) => {
+  const activeStrategies = new Set(
+    activeRuntimeEvidenceStrategies(deployment).map(
+      ({ strategyName }) => strategyName
+    )
+  );
+  for (const row of rows) {
+    if (row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !row.strategy || !activeStrategies.has(row.strategy)) {
+      throw new Error(
+        `Runtime evidence ${label} row is outside embedded deployment composition`
+      );
+    }
+  }
+};
+var readRuntimeEvidenceArtifact = async ({
+  filePath,
+  projectRoot
+}) => {
+  const resolvedPath = import_node_path3.default.resolve(projectRoot, filePath);
+  const root = asRecord(
+    JSON.parse(await import_promises3.default.readFile(resolvedPath, "utf8"))
+  );
+  const runtime = asRecord(root?.runtime) ?? root;
+  if (!root || !runtime) {
+    throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
+  }
+  const rootWindow = asRecord(root.window);
+  const runtimeWindow = asRecord(runtime.window);
+  return {
+    resolvedPath,
+    root,
+    runtime,
+    userName: String(root.userName ?? runtime.userName ?? "").trim(),
+    startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime),
+    endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime),
+    deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment)
+  };
+};
+var loadReplayRuntimeEvidenceMetadata = async (params) => {
+  const artifact = await readRuntimeEvidenceArtifact(params);
+  return {
+    path: artifact.resolvedPath,
+    userName: artifact.userName,
+    startTime: artifact.startTime,
+    endTime: artifact.endTime,
+    deployment: artifact.deployment
+  };
+};
+var buildRuntimeEvidenceLineageScopes = ({
+  signals,
+  evaluations
+}) => {
+  const scopes = /* @__PURE__ */ new Map();
+  const add = ({
+    strategy,
+    symbol,
+    deploymentId,
+    accountId,
+    runtimeConfigId,
+    runtimeVersion,
+    timestamp,
+    lineage
+  }) => {
+    if (!lineage || !Number.isFinite(timestamp)) {
+      return;
+    }
+    const key = `${deploymentId ?? "default"}::${accountId ?? "default"}::${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
+    const existing = scopes.get(key);
+    scopes.set(key, {
+      strategy,
+      symbol,
+      ...deploymentId ? { deploymentId } : {},
+      ...accountId ? { accountId } : {},
+      ...runtimeConfigId ? { runtimeConfigId } : {},
+      ...runtimeVersion ? { runtimeVersion } : {},
+      lineage,
+      firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
+      lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
+    });
+  };
+  for (const signal of signals) {
+    add({
+      strategy: signal.strategy,
+      symbol: signal.symbol,
+      deploymentId: signal.deploymentId,
+      accountId: signal.accountId,
+      runtimeConfigId: signal.runtimeConfigId,
+      runtimeVersion: signal.runtimeVersion,
+      timestamp: signal.timestamp,
+      lineage: signal.runtimeLineage
+    });
+  }
+  for (const evaluation of evaluations) {
+    add({
+      strategy: evaluation.strategy,
+      symbol: evaluation.symbol,
+      deploymentId: evaluation.deploymentId,
+      accountId: evaluation.accountId,
+      runtimeConfigId: evaluation.runtimeConfigId,
+      runtimeVersion: evaluation.runtimeVersion,
+      timestamp: evaluation.timestamp,
+      lineage: evaluation.runtimeLineage
+    });
+  }
+  return [...scopes.values()].sort(
+    (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.firstTimestamp - right.firstTimestamp
+  );
+};
+var loadReplayRuntimeEvidenceSource = async ({
+  filePath,
+  projectRoot,
+  expectedUserName,
+  expectedWindow
+}) => {
+  const { resolvedPath, runtime, userName, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot });
+  if (!userName || userName !== expectedUserName) {
+    throw new Error(
+      `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName || "missing"}`
+    );
+  }
+  const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
+  if (startTime !== expectedWindow.start || !endTimeMatches) {
+    throw new Error(
+      `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
+    );
+  }
+  const trades = unwrapRows(runtime.trades, "trade");
+  const signals = unwrapRows(runtime.signals, "signal");
+  const evaluations = unwrapRows(
+    runtime.evaluations,
+    "evaluation"
+  );
+  const storedLineageScopes = unwrapRows(
+    runtime.lineageScopes,
+    "lineageScope"
+  );
+  assertRuntimeRowsMatchDeployment({
+    label: "trade",
+    rows: trades,
+    deployment
+  });
+  assertRuntimeRowsMatchDeployment({
+    label: "signal",
+    rows: signals,
+    deployment
+  });
+  assertRuntimeRowsMatchDeployment({
+    label: "evaluation",
+    rows: evaluations,
+    deployment
+  });
+  assertRuntimeRowsMatchDeployment({
+    label: "lineage scope",
+    rows: storedLineageScopes,
+    deployment
+  });
+  return {
+    path: resolvedPath,
+    userName,
+    startTime,
+    endTime,
+    trades,
+    signals,
+    evaluations,
+    lineageScopes: storedLineageScopes.length ? storedLineageScopes : buildRuntimeEvidenceLineageScopes({ signals, evaluations }),
+    deployment
+  };
+};
+
+// src/lib/replay/support.ts
+var import_chalk8 = __toESM(require("chalk"));
+
+// src/lib/runtimeModeConfig.ts
+var buildRuntimeModeStrategyConfig = ({
+  strategyConfig,
+  env,
+  interval,
+  makeOrders,
+  recordRuntimeTrades,
+  aiReplayAnalyses
+}) => ({
+  ...strategyConfig,
+  ENV: env,
+  MAKE_ORDERS: makeOrders,
+  INTERVAL: strategyConfig.INTERVAL ?? interval,
+  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
+  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
+});
+
+// src/lib/replay/support.ts
+var REPLAY_RESULTS_BY_STRATEGY_HEADERS = [
+  import_chalk8.default.blue("STRATEGY"),
+  import_chalk8.default.yellow("TICKERS"),
+  import_chalk8.default.yellow("TRADE TICKERS"),
+  import_chalk8.default.cyan("ORDERS"),
+  import_chalk8.default.cyan("WIN/LOSS (%)"),
+  import_chalk8.default.cyan("PROFIT"),
+  import_chalk8.default.cyan("AVG TRADE")
+];
+var REPLAY_RUNTIME_COMPARISON_HEADERS = [
+  import_chalk8.default.blue("STRATEGY"),
+  import_chalk8.default.cyan("BT ENTRIES"),
+  import_chalk8.default.cyan("BT PNL"),
+  import_chalk8.default.yellow("RT TRADES"),
+  import_chalk8.default.yellow("RT PNL"),
+  import_chalk8.default.green("MATCHED"),
+  import_chalk8.default.red("ORDER FAILED"),
+  import_chalk8.default.yellow("RT ONLY"),
+  import_chalk8.default.magenta("BT ONLY"),
+  import_chalk8.default.red("UNMATCHED")
+];
+var REPLAY_RESULTS_CONFIG = "replay";
+var REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS = 1;
+var REPLAY_RUNTIME_COMPARE_TOLERANCE_MS = REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS * 15 * 60 * 1e3;
+var formatReplayRuntimeCompareTolerance = () => `${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS} ${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS === 1 ? "bar" : "bars"}`;
+var getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly + row.backtestOnly;
+var buildReplayStrategyConfig = ({
+  strategyConfig,
+  interval
+}) => buildRuntimeModeStrategyConfig({
+  strategyConfig,
+  env: "PARITY",
+  interval,
+  makeOrders: true,
+  recordRuntimeTrades: false
+});
+var toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var compactReplayAdditionalIndicators = (additionalIndicators) => {
+  const additional = toRecord(additionalIndicators);
+  if (!additional) {
+    return void 0;
+  }
+  const compact = {};
+  if (additional.executionSlippage != null) {
+    compact.executionSlippage = additional.executionSlippage;
+  }
+  if (additional.marketContext != null) {
+    compact.marketContext = additional.marketContext;
+  }
+  const baseContext = toRecord(additional.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const execution = toRecord(relative?.execution);
+  if (execution) {
+    compact.baseContext = {
+      relative: {
+        execution
+      }
+    };
+  }
+  return Object.keys(compact).length ? compact : void 0;
+};
+var compactReplaySignal = (signal) => {
+  if (!signal) {
+    return void 0;
+  }
+  return {
+    signalId: signal.signalId,
+    strategy: signal.strategy,
     symbol: signal.symbol,
     interval: signal.interval,
     direction: signal.direction,
@@ -4453,6 +5022,7 @@ var import_redis3 = require("@tradejs/infra/redis");
 var import_connectors6 = require("@tradejs/node/connectors");
 var import_cli4 = require("@tradejs/node/cli");
 var import_strategies5 = require("@tradejs/node/strategies");
+var import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
 
 // src/lib/replay/portfolioReplayConnector.ts
 var import_constants3 = require("@tradejs/core/constants");
@@ -4872,345 +5442,48 @@ var splitCandlesForReplayWindow = (candles, start, preloadStart) => {
     }
     replayData.push(candle);
   }
-  return { prevData, replayData };
-};
-var alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
-
-// src/lib/signals/hooks.ts
-var normalizeHookList = (value) => {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  return value ? [value] : [];
-};
-var invokeBeforeSignalsHooks = async (hooks, params) => {
-  for (const hook of normalizeHookList(
-    hooks?.beforeSignals
-  )) {
-    const result = await hook(params);
-    if (result?.abort === true) {
-      return result;
-    }
-  }
-  return void 0;
-};
-var invokeAfterSignalsHooks = async (hooks, params) => {
-  for (const hook of normalizeHookList(
-    hooks?.afterSignals
-  )) {
-    await hook(params);
-  }
-};
-
-// src/lib/runtimeLineage.ts
-var import_node_child_process = require("child_process");
-var import_node_crypto2 = require("crypto");
-var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
-var import_types2 = require("@tradejs/types");
-var import_strategies3 = require("@tradejs/node/strategies");
-var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
-
-// src/lib/strategyGateFingerprint.ts
-var import_node_crypto = require("crypto");
-var import_node_module = require("module");
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-var toPackageToken = (strategyName) => strategyName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
-var getStrategyPackageName = (strategyName) => strategyName === "TrendLine" || strategyName === "ReverseTrendLine" ? "@tradejs/strategy-trend-line" : `@tradejs/strategy-${toPackageToken(strategyName)}`;
-var gateFingerprintSpecifiers = (strategyName) => [
-  getStrategyPackageName(strategyName),
-  "@tradejs/strategy-kit/ai-gate",
-  "@tradejs/node/ai",
-  "@tradejs/core/strategies"
-];
-var resolveStrategyGateFingerprint = async ({
-  projectRoot,
-  strategyName,
-  gitSha
-}) => {
-  const projectManifestPath = import_node_path.default.join(projectRoot, "package.json");
-  const projectExists = await import_promises.default.access(projectManifestPath).then(() => true).catch(() => false);
-  const requireFromProject = projectExists ? (0, import_node_module.createRequire)(projectManifestPath) : null;
-  const candidates = requireFromProject ? await Promise.all(
-    gateFingerprintSpecifiers(strategyName).map(async (specifier) => {
-      let resolvedPath;
-      try {
-        resolvedPath = requireFromProject.resolve(specifier);
-      } catch {
-        return null;
-      }
-      const content = await import_promises.default.readFile(resolvedPath).catch(() => null);
-      return content == null ? null : { specifier, content };
-    })
-  ) : [];
-  const sourceEntries = candidates.filter(
-    (entry) => entry != null
-  );
-  const hash = (0, import_node_crypto.createHash)("sha256");
-  hash.update(strategyName);
-  if (sourceEntries.length) {
-    for (const entry of sourceEntries) {
-      hash.update(entry.specifier);
-      hash.update(entry.content);
-    }
-  } else {
-    hash.update(gitSha ?? "unknown-git-sha");
-  }
-  return {
-    gateFingerprint: hash.digest("hex").slice(0, 16),
-    gateFingerprintFiles: sourceEntries.map((entry) => entry.specifier)
-  };
-};
-
-// src/lib/runtimeLineage.ts
-var RUNTIME_CONTEXT_ENV_KEYS = [
-  "AI_MODE",
-  "MIN_AI_QUALITY",
-  "INTERVAL",
-  "DERIVATIVES_CONTEXT_ENABLED",
-  "DERIVATIVES_CONTEXT_TARGET_ENABLED",
-  "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
-  "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
-  "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
-  "COINMARKETCAP_CONTEXT_ENABLED",
-  "COINMARKETCAP_CONTEXT_MAX_AGE_MS",
-  "COINMARKETCAP_CONTEXT_EXCHANGE_LIQUIDITY_ENABLED",
-  "COINMARKETCAP_CONTEXT_EXCHANGE_SLUGS",
-  "COINMARKETCAP_CONTEXT_FEAR_GREED_ENABLED",
-  "COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS",
-  "COINMARKETCAP_CONTEXT_BACKFILL_ENABLED",
-  "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
-  "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS",
-  "HYPERLIQUID_WHALE_CONTEXT_ENABLED",
-  "HYPERLIQUID_WHALE_BACKFILL_ENABLED",
-  "HYPERLIQUID_WHALE_MIN_COVERAGE_PCT",
-  "HYPERLIQUID_WHALE_CONCURRENCY",
-  "HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT"
-];
-var RUNTIME_CONTEXT_DATA_MODEL = {
-  derivativesSourceIntervals: "15m",
-  derivativesDerivedIntervals: "1h",
-  derivativesHourlyFallback: "stored-1h",
-  derivativesDataModelVersion: 2,
-  coinMarketCapAvailabilityModel: "closed-interval-all-daily",
-  coinMarketCapDataModelVersion: 3,
-  binanceBreadthUniverseModel: "fixed-versioned-top5-top10-top30-top50-top100",
-  binanceBreadthDataModelVersion: 2,
-  hyperliquidWhaleCanonicalInterval: "1m",
-  hyperliquidWhaleGateMinNotionalUsd: 5e4,
-  hyperliquidWhaleMinCoveragePct: 0.8,
-  hyperliquidWhaleDataModelVersion: import_types2.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-};
-var normalizeForStableJson = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeForStableJson);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
-    );
-  }
-  return value;
-};
-var resolveRuntimeMaxLossValue = (config) => {
-  if (!config || typeof config !== "object" || Array.isArray(config)) {
-    return null;
-  }
-  const strategyConfig = config.strategyConfig;
-  if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
-    return null;
-  }
-  const maxLossValue = Number(
-    strategyConfig.MAX_LOSS_VALUE
-  );
-  return Number.isFinite(maxLossValue) ? maxLossValue : null;
-};
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
-var gitLineageCache = /* @__PURE__ */ new Map();
-var gateFingerprintCache = /* @__PURE__ */ new Map();
-var binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
-var snapshotFingerprintCache = /* @__PURE__ */ new Map();
-var resolveGitLineage = (projectRoot) => {
-  const cached = gitLineageCache.get(projectRoot);
-  if (cached) {
-    return cached;
-  }
-  const envSha = String(process.env.TRADEJS_GIT_SHA ?? "").trim();
-  if (envSha && envSha !== "unknown") {
-    const result = {
-      gitSha: envSha,
-      gitDirty: false
-    };
-    gitLineageCache.set(projectRoot, result);
-    return result;
-  }
-  try {
-    const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
-      cwd: projectRoot,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    const status = (0, import_node_child_process.execFileSync)(
-      "git",
-      ["status", "--porcelain", "--untracked-files=normal"],
-      {
-        cwd: projectRoot,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }
-    ).trim();
-    const result = {
-      gitSha: gitSha || null,
-      gitDirty: status.length > 0
-    };
-    gitLineageCache.set(projectRoot, result);
-    return result;
-  } catch {
-    const result = {
-      gitSha: null,
-      gitDirty: null
-    };
-    gitLineageCache.set(projectRoot, result);
-    return result;
-  }
-};
-var readOptionalFile = async (filePath) => {
-  try {
-    return await import_promises2.default.readFile(filePath);
-  } catch {
-    return null;
-  }
-};
-var resolveBinanceBreadthFingerprint = async (projectRoot) => {
-  if (binanceBreadthFingerprintCache.has(projectRoot)) {
-    return binanceBreadthFingerprintCache.get(projectRoot) ?? null;
-  }
-  const content = await readOptionalFile(
-    import_node_path2.default.join(
-      projectRoot,
-      "packages/node/src/config/binanceBreadthUniverses.json"
-    )
-  );
-  let result = null;
-  if (content) {
-    try {
-      const parsed = JSON.parse(content.toString("utf8"));
-      result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
-    } catch {
-      result = null;
-    }
-  }
-  binanceBreadthFingerprintCache.set(projectRoot, result);
-  return result;
-};
-var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
-  const cacheKey = `${projectRoot}:${relativePath}`;
-  if (snapshotFingerprintCache.has(cacheKey)) {
-    return snapshotFingerprintCache.get(cacheKey) ?? null;
-  }
-  const content = await readOptionalFile(import_node_path2.default.join(projectRoot, relativePath));
-  let result = null;
-  if (content) {
-    try {
-      const parsed = JSON.parse(content.toString("utf8"));
-      result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
-    } catch {
-      result = null;
-    }
-  }
-  snapshotFingerprintCache.set(cacheKey, result);
-  return result;
+  return { prevData, replayData };
 };
-var resolveRuntimeGateFingerprint = async ({
-  projectRoot,
-  strategyName,
-  gitSha
-}) => {
-  const cacheKey = `${projectRoot}:${strategyName}:${gitSha ?? "unknown"}`;
-  const cached = gateFingerprintCache.get(cacheKey);
-  if (cached) return cached;
-  const result = await resolveStrategyGateFingerprint({
-    projectRoot,
-    strategyName,
-    gitSha
-  });
-  gateFingerprintCache.set(cacheKey, result);
-  return result;
+var alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
+
+// src/lib/signals/hooks.ts
+var normalizeHookList = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value ? [value] : [];
 };
-async function buildRuntimeLineage({
-  projectRoot,
-  strategyName,
-  compositionId,
-  version,
-  strategyPackageVersion,
-  runtimePackageVersion,
-  config,
-  runContext,
-  env = process.env
-}) {
-  if (version != null) {
-    if (!Number.isSafeInteger(version) || version <= 0) {
-      throw new Error(`Invalid runtime strategy version: ${version}`);
+var invokeBeforeSignalsHooks = async (hooks, params) => {
+  for (const hook of normalizeHookList(
+    hooks?.beforeSignals
+  )) {
+    const result = await hook(params);
+    if (result?.abort === true) {
+      return result;
     }
-    return {
-      schemaVersion: 2,
-      version,
-      strategyPackageVersion,
-      runtimePackageVersion,
-      maxLossValue: resolveRuntimeMaxLossValue(config)
-    };
   }
-  const git = resolveGitLineage(projectRoot);
-  const hyperliquidPerpUniverseFingerprint = typeof import_strategies3.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies3.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
-    projectRoot,
-    "packages/node/src/config/hyperliquidPerpUniverse.json"
-  );
-  const hyperliquidWhaleRegistryFingerprint = typeof import_strategies3.getHyperliquidWhaleRegistrySnapshot === "function" ? (0, import_strategies3.getHyperliquidWhaleRegistrySnapshot)().fingerprint : await resolveSnapshotFingerprint(
-    projectRoot,
-    "packages/node/src/config/hyperliquidWhales.json"
-  );
-  const context = {
-    ...Object.fromEntries(
-      RUNTIME_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
-    ),
-    ...RUNTIME_CONTEXT_DATA_MODEL,
-    binanceBreadthUniverseFingerprint: await resolveBinanceBreadthFingerprint(projectRoot),
-    hyperliquidPerpUniverseFingerprint,
-    hyperliquidWhaleRegistryFingerprint,
-    ...runContext
-  };
-  return {
-    schemaVersion: 1,
-    compositionId: compositionId?.trim() || null,
-    ...git,
-    gateFingerprint: (await resolveRuntimeGateFingerprint({
-      projectRoot,
-      strategyName,
-      gitSha: git.gitSha
-    })).gateFingerprint,
-    // Position risk is tracked separately so changing trade size does not
-    // masquerade as a change to the core + gate decision logic.
-    configFingerprint: (0, import_strategyReleaseEvidence.strategyLogicConfigFingerprint)(config),
-    contextFingerprint: fingerprintRuntimeValue(context),
-    maxLossValue: resolveRuntimeMaxLossValue(config)
-  };
-}
-var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.version].join(":") : [
-  lineage.schemaVersion,
-  lineage.compositionId ?? "unbound-composition",
-  lineage.gitSha ?? "unknown",
-  lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
-  lineage.gateFingerprint,
-  lineage.configFingerprint,
-  lineage.contextFingerprint
-].join(":");
-var runtimeLineagesMatch = (left, right) => left != null && right != null && runtimeLineageKey(left) === runtimeLineageKey(right);
+  return void 0;
+};
+var invokeAfterSignalsHooks = async (hooks, params) => {
+  for (const hook of normalizeHookList(
+    hooks?.afterSignals
+  )) {
+    await hook(params);
+  }
+};
 
 // src/lib/replay/historicalSignalsReplay.ts
 var loadRuntimeStrategies = async (runtimeStrategies) => {
   const strategies = await Promise.all(
-    runtimeStrategies.map(async ({ strategyName, strategyConfig }) => {
+    runtimeStrategies.map(async (runtimeStrategy) => {
+      const {
+        strategyName,
+        version,
+        strategyPackage,
+        strategyPackageVersion,
+        runtimePackageVersion,
+        strategyConfig
+      } = runtimeStrategy;
       const strategyCreator = await (0, import_strategies5.getStrategyCreator)(
         strategyName,
         replayProjectRoot
@@ -5218,12 +5491,25 @@ var loadRuntimeStrategies = async (runtimeStrategies) => {
       if (!strategyCreator) {
         throw new Error(`Unknown strategy: ${strategyName}`);
       }
+      const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
+        strategyName,
+        projectRoot: replayProjectRoot
+      });
+      if (installed.strategyPackage !== strategyPackage || installed.strategyPackageVersion !== strategyPackageVersion || installed.runtimePackageVersion !== runtimePackageVersion) {
+        throw new Error(
+          `Runtime evidence package mismatch for ${strategyName}: expected=${strategyPackage}@${strategyPackageVersion}/@tradejs/node@${runtimePackageVersion}, installed=${installed.strategyPackage ?? "missing"}@${installed.strategyPackageVersion ?? "missing"}/@tradejs/node@${installed.runtimePackageVersion ?? "missing"}`
+        );
+      }
       const strategyResults = await (0, import_redis3.getData)(
         import_redis3.redisKeys.strategyResults(replayUserName, strategyName),
         {}
       );
       return {
         strategyName,
+        version,
+        strategyPackage,
+        strategyPackageVersion,
+        runtimePackageVersion,
         strategyCreator,
         strategyConfig,
         strategyResults
@@ -5417,6 +5703,9 @@ var runHistoricalSignalsReplay = async ({
       loadedStrategies.map(
         async ({
           strategyName,
+          version,
+          strategyPackageVersion,
+          runtimePackageVersion,
           strategyCreator,
           strategyConfig,
           strategyResults
@@ -5424,8 +5713,11 @@ var runHistoricalSignalsReplay = async ({
           const runtimeLineage = await buildRuntimeLineage({
             projectRoot: replayProjectRoot,
             strategyName,
+            version,
+            strategyPackageVersion,
+            runtimePackageVersion,
             config: {
-              configId: "config",
+              configId: `v${version}`,
               strategyConfig,
               symbolResultConfig: strategyResults?.[symbol]?.config ?? null
             },
@@ -5438,6 +5730,8 @@ var runHistoricalSignalsReplay = async ({
           runtimeLineages.push({
             strategy: strategyName,
             symbol,
+            ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
+            ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
             lineage: runtimeLineage
           });
           return {
@@ -5447,8 +5741,11 @@ var runHistoricalSignalsReplay = async ({
             run: await strategyCreator({
               userName: replayUserName,
               connectorName,
-              runtimeConfigId: "config",
+              runtimeConfigId: `v${version}`,
               runtimeLineage,
+              universe: preparedRun.universe,
+              accountId: preparedRun.accountId,
+              deploymentId: preparedRun.deploymentId,
               config: buildReplayStrategyConfig({
                 strategyConfig,
                 interval
@@ -7211,118 +7508,6 @@ var buildReplayExchangeComparisonDetails = ({
   };
 };
 
-// src/lib/replay/runtimeEvidenceSource.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-var unwrapRows = (value, field) => (Array.isArray(value) ? value : []).map((item) => {
-  const row = asRecord(item);
-  return asRecord(row?.[field]) ?? row;
-}).filter((item) => item != null);
-var buildRuntimeEvidenceLineageScopes = ({
-  signals,
-  evaluations
-}) => {
-  const scopes = /* @__PURE__ */ new Map();
-  const add = ({
-    strategy,
-    symbol,
-    runtimeConfigId,
-    runtimeVersion,
-    timestamp,
-    lineage
-  }) => {
-    if (!lineage || !Number.isFinite(timestamp)) {
-      return;
-    }
-    const key = `${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
-    const existing = scopes.get(key);
-    scopes.set(key, {
-      strategy,
-      symbol,
-      ...runtimeConfigId ? { runtimeConfigId } : {},
-      ...runtimeVersion ? { runtimeVersion } : {},
-      lineage,
-      firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
-      lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
-    });
-  };
-  for (const signal of signals) {
-    add({
-      strategy: signal.strategy,
-      symbol: signal.symbol,
-      runtimeConfigId: signal.runtimeConfigId,
-      runtimeVersion: signal.runtimeVersion,
-      timestamp: signal.timestamp,
-      lineage: signal.runtimeLineage
-    });
-  }
-  for (const evaluation of evaluations) {
-    add({
-      strategy: evaluation.strategy,
-      symbol: evaluation.symbol,
-      runtimeConfigId: evaluation.runtimeConfigId,
-      runtimeVersion: evaluation.runtimeVersion,
-      timestamp: evaluation.timestamp,
-      lineage: evaluation.runtimeLineage
-    });
-  }
-  return [...scopes.values()].sort(
-    (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.firstTimestamp - right.firstTimestamp
-  );
-};
-var loadReplayRuntimeEvidenceSource = async ({
-  filePath,
-  projectRoot,
-  expectedUserName,
-  expectedWindow
-}) => {
-  const resolvedPath = import_node_path3.default.resolve(projectRoot, filePath);
-  const root = asRecord(
-    JSON.parse(await import_promises3.default.readFile(resolvedPath, "utf8"))
-  );
-  const runtime = asRecord(root?.runtime) ?? root;
-  if (!root || !runtime) {
-    throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
-  }
-  const rootWindow = asRecord(root.window);
-  const runtimeWindow = asRecord(runtime.window);
-  const startTime = asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime);
-  const endTime = asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime);
-  const userName = String(root.userName ?? runtime.userName ?? "").trim();
-  if (!userName || userName !== expectedUserName) {
-    throw new Error(
-      `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName || "missing"}`
-    );
-  }
-  const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
-  if (startTime !== expectedWindow.start || !endTimeMatches) {
-    throw new Error(
-      `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
-    );
-  }
-  const trades = unwrapRows(runtime.trades, "trade");
-  const signals = unwrapRows(runtime.signals, "signal");
-  const evaluations = unwrapRows(
-    runtime.evaluations,
-    "evaluation"
-  );
-  return {
-    path: resolvedPath,
-    userName,
-    startTime,
-    endTime,
-    trades,
-    signals,
-    evaluations,
-    lineageScopes: buildRuntimeEvidenceLineageScopes({
-      signals,
-      evaluations
-    })
-  };
-};
-
 // src/lib/replay/runtimeComparison.ts
 var getReplayEntryTimestampCompareOffsetMs = () => {
   const intervalMinutes = Number(replayInterval);
@@ -7340,27 +7525,40 @@ var buildReplaySignalEvaluations = (signals) => signals.map((signal) => ({
   reason: signal.orderSkipReason || signal.orderStatus || "SIGNAL",
   signalId: signal.signalId,
   direction: signal.direction,
+  accountId: signal.accountId,
+  deploymentId: signal.deploymentId,
   runtimeLineage: signal.runtimeLineage,
   orderStatus: signal.orderStatus,
   orderSkipReason: signal.orderSkipReason,
   ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
   ...signal.ml ? { ml: signal.ml } : {}
 }));
-var lineageScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
+var lineageScopeKey = ({
+  strategy,
+  symbol,
+  deploymentId,
+  accountId
+}) => `${deploymentId ?? "default-deployment"}::${accountId ?? "default-account"}::${strategy}::${symbol}`;
 var buildExpectedLineageByScope = (replayLineages) => new Map(
-  replayLineages.map((record) => [
-    lineageScopeKey(record.strategy, record.symbol),
-    record.lineage
-  ])
+  replayLineages.map((record) => [lineageScopeKey(record), record.lineage])
 );
 var hasExpectedLineage = ({
   strategy,
   symbol,
+  deploymentId,
+  accountId,
   lineage,
   expectedByScope
-}) => runtimeLineagesMatch(
+}) => runtimeLineagesComparable(
   lineage,
-  expectedByScope.get(lineageScopeKey(strategy, symbol))
+  expectedByScope.get(
+    lineageScopeKey({
+      strategy,
+      symbol,
+      deploymentId,
+      accountId
+    })
+  )
 );
 var filterReplayComparisonByLineage = ({
   replayLineages,
@@ -7375,6 +7573,8 @@ var filterReplayComparisonByLineage = ({
     (signal) => hasExpectedLineage({
       strategy: signal.strategy,
       symbol: signal.symbol,
+      deploymentId: signal.deploymentId,
+      accountId: signal.accountId,
       lineage: signal.runtimeLineage,
       expectedByScope
     })
@@ -7383,6 +7583,8 @@ var filterReplayComparisonByLineage = ({
     (evaluation) => hasExpectedLineage({
       strategy: evaluation.strategy,
       symbol: evaluation.symbol,
+      deploymentId: evaluation.deploymentId,
+      accountId: evaluation.accountId,
       lineage: evaluation.runtimeLineage,
       expectedByScope
     })
@@ -7391,13 +7593,15 @@ var filterReplayComparisonByLineage = ({
     (scope) => hasExpectedLineage({
       strategy: scope.strategy,
       symbol: scope.symbol,
+      deploymentId: scope.deploymentId,
+      accountId: scope.accountId,
       lineage: scope.lineage,
       expectedByScope
     })
   );
   const deploymentWindows = /* @__PURE__ */ new Map();
   for (const scope of comparableRuntimeLineageScopes) {
-    const key = lineageScopeKey(scope.strategy, scope.symbol);
+    const key = lineageScopeKey(scope);
     const existing = deploymentWindows.get(key);
     deploymentWindows.set(key, {
       firstTimestamp: existing == null ? scope.firstTimestamp : Math.min(existing.firstTimestamp, scope.firstTimestamp),
@@ -7421,13 +7625,13 @@ var filterReplayComparisonByLineage = ({
       return hasExpectedLineage({
         strategy: trade.strategy,
         symbol: trade.symbol,
+        deploymentId: trade.deploymentId,
+        accountId: trade.accountId,
         lineage,
         expectedByScope
       });
     }
-    const window = deploymentWindows.get(
-      lineageScopeKey(trade.strategy, trade.symbol)
-    );
+    const window = deploymentWindows.get(lineageScopeKey(trade));
     const signalTimestamp = trade.signalTimestamp ?? trade.entryTimestamp;
     return window != null && signalTimestamp >= window.firstTimestamp && signalTimestamp <= window.lastTimestamp;
   });
@@ -7435,17 +7639,24 @@ var filterReplayComparisonByLineage = ({
     ...comparableRuntimeSignals,
     ...comparableRuntimeEvaluations
   ]) {
-    const key = lineageScopeKey(artifact.strategy, artifact.symbol);
+    const key = lineageScopeKey(artifact);
     const existing = deploymentWindows.get(key);
     deploymentWindows.set(key, {
       firstTimestamp: existing == null ? artifact.timestamp : Math.min(existing.firstTimestamp, artifact.timestamp),
       lastTimestamp: existing == null ? artifact.timestamp : Math.max(existing.lastTimestamp, artifact.timestamp)
     });
   }
+  const replayScopeByStrategySymbol = new Map(
+    replayLineages.map((record) => [
+      `${record.strategy}::${record.symbol}`,
+      lineageScopeKey(record)
+    ])
+  );
   const comparableBacktestEntries = backtestEntries.filter((entry) => {
-    const window = deploymentWindows.get(
-      lineageScopeKey(entry.strategy, entry.symbol)
+    const replayScope = replayScopeByStrategySymbol.get(
+      `${entry.strategy}::${entry.symbol}`
     );
+    const window = replayScope ? deploymentWindows.get(replayScope) : null;
     const signalTimestamp = entry.signalTimestamp ?? entry.timestamp;
     return window != null && signalTimestamp >= window.firstTimestamp && signalTimestamp <= window.lastTimestamp;
   });
@@ -7467,10 +7678,12 @@ var filterReplayComparisonByLineage = ({
       excludedBacktestEntries: backtestEntries.length - comparableBacktestEntries.length,
       reason: comparableScopeKeys.size > 0 ? null : "no_runtime_artifacts_with_matching_lineage",
       replay: [...expectedByScope.entries()].map(([scope, lineage]) => {
-        const separator = scope.indexOf("::");
+        const [deploymentId, accountId, strategy, symbol] = scope.split("::");
         return {
-          strategy: scope.slice(0, separator),
-          symbol: scope.slice(separator + 2),
+          deploymentId,
+          accountId,
+          strategy,
+          symbol,
           lineage
         };
       }).sort(
@@ -8874,10 +9087,69 @@ var finishReplay = async ({
 };
 var replayBacktest = async () => {
   resetRunState();
+  const evidenceMetadata = replayRuntimeEvidencePath ? await loadReplayRuntimeEvidenceMetadata({
+    filePath: replayRuntimeEvidencePath,
+    projectRoot: replayProjectRoot
+  }) : null;
+  if (evidenceMetadata && evidenceMetadata.userName !== replayUserName) {
+    throw new Error(
+      `Runtime evidence user mismatch: expected=${replayUserName}, actual=${evidenceMetadata.userName || "missing"}`
+    );
+  }
+  const replayComposition = evidenceMetadata ? {
+    deployment: runtimeDeploymentFromEvidence(evidenceMetadata.deployment),
+    strategies: activeRuntimeEvidenceStrategies(
+      evidenceMetadata.deployment
+    ).map(
+      ({
+        strategyName,
+        version,
+        strategyPackage,
+        strategyPackageVersion,
+        runtimePackageVersion,
+        strategyConfig
+      }) => ({
+        strategyName,
+        version,
+        strategyPackage,
+        strategyPackageVersion,
+        runtimePackageVersion,
+        strategyConfig
+      })
+    )
+  } : await loadDeploymentReplayStrategies({
+    userName: replayUserName,
+    projectRoot: replayProjectRoot,
+    deploymentId: replayDeploymentId
+  });
+  const { deployment, strategies: replayStrategies } = replayComposition;
+  if (!replayStrategies.length) {
+    throw new Error(`No enabled strategies in deployment ${deployment.id}`);
+  }
+  const strategyIntervals = new Set(
+    replayStrategies.map(
+      ({ strategyConfig }) => String(strategyConfig.INTERVAL)
+    )
+  );
+  if (strategyIntervals.size !== 1 || !strategyIntervals.has(replayInterval)) {
+    throw new Error(
+      `Replay interval does not match deployment ${deployment.id}: replay=${replayInterval}, strategies=${[...strategyIntervals].join(",")}`
+    );
+  }
+  const strategyUniverses = new Set(
+    replayStrategies.map(
+      ({ strategyConfig }) => String(strategyConfig.UNIVERSE)
+    )
+  );
+  if (strategyUniverses.size !== 1) {
+    throw new Error(
+      `Replay requires one deployment universe: ${[...strategyUniverses].join(",")}`
+    );
+  }
   const preparedRun = await prepareRunEnvironment({
-    connector: replayFlags.connector,
+    connector: deployment.connectorName,
     userName: replayUserName,
-    tickers: replayFlags.tickers,
+    tickers: replayFlags.tickers ?? deployment.tickers,
     exclude: replayFlags.exclude,
     tickersLimit: replayFlags.tickersLimit,
     showTickersList: replayFlags.showTickersList,
@@ -8887,6 +9159,11 @@ var replayBacktest = async () => {
     cacheOnly: replayFlags.cacheOnly,
     interval: replayInterval,
     projectRoot: replayProjectRoot,
+    universe: [...strategyUniverses][0],
+    accountId: deployment.accountId,
+    deploymentId: deployment.id,
+    assetClasses: deployment.assetClasses,
+    deployment,
     closedIntervalMs: (0, import_data2.intervalToMs)(replayInterval)
   });
   if (!preparedRun || isReplayUpdateOnlyRun) {
@@ -8900,10 +9177,6 @@ var replayBacktest = async () => {
       end: preparedRun.window.end
     }
   });
-  const replayStrategies = await loadReplayStrategies(replayUserName);
-  if (!replayStrategies.length) {
-    return;
-  }
   await prepareReplayBinanceMarketContext({
     ...preparedRun,
     aiEnabled: replayStrategies.some(