@tradejs/cli 3.1.16 → 3.1.17

package/dist/scripts/replay.js

@@ -111,9 +111,7 @@ var loadRuntimeTrades = async (userName, {
       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;
-    }
+    return windowedTrades;
   }
   const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
   const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
@@ -2706,27 +2704,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-var getCoinMarketCapPathLabel = (path5) => {
-  if (path5.includes("global-metrics")) return "global";
-  if (path5.includes("cryptocurrency/quotes")) return "reference";
-  if (path5.includes("exchange/quotes")) return "exchangeLiquidity";
-  if (path5.includes("fear-and-greed")) return "fearGreed";
-  if (path5.includes("cmc100")) return "cmc100";
-  if (path5.includes("cmc20")) return "cmc20";
-  return path5;
-};
-var recordCoinMarketCapFetchStats = (stats, path5, creditCount) => {
+var getCoinMarketCapPathLabel = (path3) => {
+  if (path3.includes("global-metrics")) return "global";
+  if (path3.includes("cryptocurrency/quotes")) return "reference";
+  if (path3.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path3.includes("fear-and-greed")) return "fearGreed";
+  if (path3.includes("cmc100")) return "cmc100";
+  if (path3.includes("cmc20")) return "cmc20";
+  return path3;
+};
+var recordCoinMarketCapFetchStats = (stats, path3, creditCount) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path5) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path3) ?? { requests: 0, credits: 0 };
   existing.requests += 1;
   existing.credits += creditCount ?? 0;
   stats.requests += 1;
   stats.totalCredits += creditCount ?? 0;
-  stats.byPath.set(path5, existing);
+  stats.byPath.set(path3, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path5, item]) => `${getCoinMarketCapPathLabel(path5)}=${item.requests}req/${item.credits}cr`
+    ([path3, item]) => `${getCoinMarketCapPathLabel(path3)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -4347,109 +4345,11 @@ var replayDeploymentId = String(
 var isReplayUpdateOnlyRun = Boolean(replayFlags.updateOnly);
 
 // src/lib/replay/runtimeEvidenceSource.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
-
-// 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 import_node_crypto = require("crypto");
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -4474,210 +4374,48 @@ var resolveRuntimeMaxLossValue = (config) => {
   );
   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,
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var buildRuntimeLineage = async ({
   strategyRevision,
   deploymentCompositionId,
   strategyPackageVersion,
   strategyDependencyVersions,
   runtimePackageVersion,
-  config,
-  runContext,
-  env = process.env
-}) {
-  if (strategyRevision != null) {
-    if (!/^sr1:[a-f0-9]{16}$/.test(strategyRevision)) {
-      throw new Error(`Invalid strategy revision: ${strategyRevision}`);
-    }
-    if (typeof deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(deploymentCompositionId)) {
-      throw new Error(
-        `Invalid deployment composition id: ${String(deploymentCompositionId)}`
-      );
-    }
-    if (typeof strategyPackageVersion !== "string" || !strategyPackageVersion.trim() || typeof runtimePackageVersion !== "string" || !runtimePackageVersion.trim()) {
-      throw new Error("Invalid revision package versions");
-    }
-    if (!strategyDependencyVersions || Object.keys(strategyDependencyVersions).length === 0 || Object.entries(strategyDependencyVersions).some(
-      ([name, version]) => !name.startsWith("@tradejs/") || typeof version !== "string" || !version.trim()
-    )) {
-      throw new Error("Invalid strategy dependency versions");
-    }
-    return {
-      schemaVersion: 3,
-      strategyRevision,
-      deploymentCompositionId,
-      strategyPackageVersion,
-      strategyDependencyVersions,
-      runtimePackageVersion,
-      maxLossValue: resolveRuntimeMaxLossValue(config)
-    };
+  config
+}) => {
+  if (!/^sr1:[a-f0-9]{16}$/.test(strategyRevision)) {
+    throw new Error(`Invalid strategy revision: ${strategyRevision}`);
+  }
+  if (!/^dc1:[a-f0-9]{16}$/.test(deploymentCompositionId)) {
+    throw new Error(
+      `Invalid deployment composition id: ${deploymentCompositionId}`
+    );
+  }
+  if (!strategyPackageVersion.trim() || !runtimePackageVersion.trim()) {
+    throw new Error("Invalid revision package versions");
+  }
+  if (Object.keys(strategyDependencyVersions).length === 0 || Object.entries(strategyDependencyVersions).some(
+    ([name, version]) => !name.startsWith("@tradejs/") || typeof version !== "string" || !version.trim()
+  )) {
+    throw new Error("Invalid strategy dependency versions");
   }
-  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),
+    schemaVersion: 3,
+    strategyRevision,
+    deploymentCompositionId,
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion,
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
-}
-var runtimeLineageKey = (lineage) => lineage.schemaVersion === 3 ? [
+};
+var runtimeLineageKey = (lineage) => [
   "v3",
   lineage.deploymentCompositionId,
   lineage.strategyRevision,
   lineage.strategyPackageVersion,
-  `deps:${fingerprintRuntimeValue(
-    lineage.strategyDependencyVersions
-  ).slice(0, 16)}`,
+  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
   lineage.runtimePackageVersion
-].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;
@@ -4716,7 +4454,7 @@ var samePackageVersions = (left, right) => {
   );
   return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
 };
-var lineageMatchesStrategySnapshot = ({
+var runtimeLineageMatchesStrategySnapshot = ({
   lineage,
   deployment,
   strategy
@@ -4763,6 +4501,82 @@ var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
   };
 };
 var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
+  const record = isRecord(candidate) ? candidate : null;
+  const nested = record && isRecord(record[field]) ? record[field] : null;
+  return nested ?? record;
+}).filter((record) => record != null);
+var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
+  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
+    throw new Error("Invalid runtime evidence artifact");
+  }
+  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+    artifact.deployment
+  );
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length === 0) {
+    throw new Error("Runtime evidence deployment has no enabled strategies");
+  }
+  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
+  if (!runtime) {
+    throw new Error("Runtime evidence payload is missing");
+  }
+  if ("strategyConfigs" in runtime) {
+    throw new Error(
+      "Runtime evidence payload contains removed strategyConfigs data"
+    );
+  }
+  const rowFields = [
+    "trades",
+    "signals",
+    "evaluations",
+    "lineageScopes"
+  ];
+  for (const field of rowFields) {
+    if (!Array.isArray(runtime[field])) {
+      throw new Error(`Runtime evidence payload ${field} must be an array`);
+    }
+  }
+  const snapshots = new Map(
+    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
+  );
+  const assertRows = (label, rows, lineageField) => {
+    for (const row of rows) {
+      const strategyName = String(row.strategy ?? "").trim();
+      const strategy = snapshots.get(strategyName);
+      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
+        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
+        deployment,
+        strategy
+      })) {
+        throw new Error(
+          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
+        );
+      }
+    }
+  };
+  assertRows(
+    "trade",
+    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "signal",
+    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "evaluation",
+    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "lineage scope",
+    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
+    "lineage"
+  );
+  return deployment;
+};
 var resolveRuntimeEvidenceTickerUniverse = ({
   deployment,
   lineageScopes
@@ -4795,7 +4609,7 @@ var resolveRuntimeEvidenceTickerUniverse = ({
   const tickers = /* @__PURE__ */ new Set();
   for (const scope of lineageScopes) {
     const strategy = strategiesByName.get(scope.strategy);
-    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !lineageMatchesStrategySnapshot({
+    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !runtimeLineageMatchesStrategySnapshot({
       lineage: scope.lineage,
       deployment,
       strategy
@@ -4861,14 +4675,15 @@ var readRuntimeEvidenceArtifact = async ({
   filePath,
   projectRoot
 }) => {
-  const resolvedPath = import_node_path3.default.resolve(projectRoot, filePath);
+  const resolvedPath = import_node_path.default.resolve(projectRoot, filePath);
   const root = asRecord(
-    JSON.parse(await import_promises3.default.readFile(resolvedPath, "utf8"))
+    JSON.parse(await import_promises.default.readFile(resolvedPath, "utf8"))
   );
   const runtime = asRecord(root?.runtime) ?? root;
   if (!root || !runtime) {
     throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
   }
+  assertCurrentRuntimeEvidenceArtifact(root);
   const rootWindow = asRecord(root.window);
   const runtimeWindow = asRecord(runtime.window);
   return {
@@ -5129,13 +4944,13 @@ var compactReplaySignal = (signal) => {
 var import_chalk9 = __toESM(require("chalk"));
 var import_progress4 = __toESM(require("progress"));
 var import_backtest = require("@tradejs/core/backtest");
-var import_strategies4 = require("@tradejs/core/strategies");
+var import_strategies3 = require("@tradejs/core/strategies");
 var import_time3 = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
 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_strategies4 = require("@tradejs/node/strategies");
 var import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
 
 // src/lib/replay/portfolioReplayConnector.ts
@@ -5601,7 +5416,7 @@ var loadRuntimeStrategies = async (runtimeStrategies) => {
         strategyConfig,
         selection
       } = runtimeStrategy;
-      const strategyCreator = await (0, import_strategies5.getStrategyCreator)(
+      const strategyCreator = await (0, import_strategies4.getStrategyCreator)(
         strategyName,
         replayProjectRoot
       );
@@ -5840,8 +5655,6 @@ var runHistoricalSignalsReplay = async ({
           strategyResults
         }) => {
           const runtimeLineage = await buildRuntimeLineage({
-            projectRoot: replayProjectRoot,
-            strategyName,
             strategyRevision,
             deploymentCompositionId,
             strategyPackageVersion,
@@ -5851,11 +5664,6 @@ var runHistoricalSignalsReplay = async ({
               configId: strategyRevision,
               strategyConfig,
               symbolResultConfig: strategyResults?.[symbol]?.config ?? null
-            },
-            runContext: {
-              connectorName: connectorName.toLowerCase(),
-              interval: String(interval),
-              universe: preparedRun.universe ?? null
             }
           });
           runtimeLineages.push({
@@ -5986,7 +5794,7 @@ var runHistoricalSignalsReplay = async ({
           );
           if (result && typeof result !== "string") {
             result.runtimeLineage = strategyRuntime.runtimeLineage;
-            await (0, import_strategies5.enrichSignalWithBinanceMarketContext)({
+            await (0, import_strategies4.enrichSignalWithBinanceMarketContext)({
               signal: result,
               env: "PARITY"
             });
@@ -6010,8 +5818,8 @@ var runHistoricalSignalsReplay = async ({
     }
   } finally {
     for (const keyPrefix of sharedReplayKeyPrefixes) {
-      (0, import_strategies4.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-      (0, import_strategies4.releaseStrategyReplayCache)(keyPrefix);
+      (0, import_strategies3.releaseStrategyIndicatorsReplayCache)(keyPrefix);
+      (0, import_strategies3.releaseStrategyReplayCache)(keyPrefix);
     }
   }
   const artifacts = replayConnector.getReplayArtifacts();
@@ -8668,8 +8476,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
 };
 
 // src/lib/replay/outputReport.ts
-var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path4 = __toESM(require("path"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
 var import_data = require("@tradejs/core/data");
 var formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
   timeZone: "Europe/Moscow",
@@ -8908,33 +8716,20 @@ var renderLineageRows = (runtimeComparison) => {
     const existing = grouped.get(record.strategy) ?? {
       strategy: record.strategy,
       scopes: 0,
-      gitShas: /* @__PURE__ */ new Set(),
-      dirty: /* @__PURE__ */ new Set(),
-      gates: /* @__PURE__ */ new Set(),
-      configs: /* @__PURE__ */ new Set(),
-      contexts: /* @__PURE__ */ new Set()
+      deploymentCompositions: /* @__PURE__ */ new Set(),
+      strategyRevisions: /* @__PURE__ */ new Set(),
+      strategyPackages: /* @__PURE__ */ new Set(),
+      dependencySets: /* @__PURE__ */ new Set(),
+      runtimePackages: /* @__PURE__ */ new Set()
     };
     existing.scopes += 1;
-    if (record.lineage.schemaVersion === 3) {
-      existing.gitShas.add(record.lineage.deploymentCompositionId);
-      existing.dirty.add("n/a");
-      existing.gates.add("package-owned");
-      existing.configs.add(record.lineage.strategyRevision);
-      existing.contexts.add(
-        [
-          record.lineage.strategyPackageVersion,
-          record.lineage.runtimePackageVersion
-        ].join("/")
-      );
-    } else {
-      existing.gitShas.add(record.lineage.gitSha ?? "unknown");
-      existing.dirty.add(
-        record.lineage.gitDirty == null ? "unknown" : String(record.lineage.gitDirty)
-      );
-      existing.gates.add(record.lineage.gateFingerprint);
-      existing.configs.add(record.lineage.configFingerprint);
-      existing.contexts.add(record.lineage.contextFingerprint);
-    }
+    existing.deploymentCompositions.add(record.lineage.deploymentCompositionId);
+    existing.strategyRevisions.add(record.lineage.strategyRevision);
+    existing.strategyPackages.add(record.lineage.strategyPackageVersion);
+    existing.dependencySets.add(
+      Object.entries(record.lineage.strategyDependencyVersions).sort(([left], [right]) => left.localeCompare(right)).map(([name, version]) => `${name}@${version}`).join(", ")
+    );
+    existing.runtimePackages.add(record.lineage.runtimePackageVersion);
     grouped.set(record.strategy, existing);
   }
   const formatSet = (values) => {
@@ -8945,29 +8740,29 @@ var renderLineageRows = (runtimeComparison) => {
     [
       "Strategy",
       "Scopes",
-      "Git SHA",
-      "Dirty",
-      "Gate",
-      "Config variants",
-      "Context"
+      "Deployment composition",
+      "Strategy revision",
+      "Strategy package",
+      "Dependencies",
+      "Runtime package"
     ],
     [...grouped.values()].sort((left, right) => left.strategy.localeCompare(right.strategy)).map(
       ({
         strategy,
         scopes,
-        gitShas,
-        dirty,
-        gates,
-        configs,
-        contexts
+        deploymentCompositions,
+        strategyRevisions,
+        strategyPackages,
+        dependencySets,
+        runtimePackages
       }) => [
         strategy,
         scopes,
-        formatSet(gitShas),
-        formatSet(dirty),
-        formatSet(gates),
-        `${configs.size}: ${formatSet(configs)}`,
-        formatSet(contexts)
+        formatSet(deploymentCompositions),
+        formatSet(strategyRevisions),
+        formatSet(strategyPackages),
+        formatSet(dependencySets),
+        formatSet(runtimePackages)
       ]
     )
   ) : "_No replay lineage records._";
@@ -8986,8 +8781,8 @@ var writeReplayOutputReport = async ({
   strategySnapshot,
   runtimeComparison
 }) => {
-  const outputDir = import_node_path4.default.resolve(projectRoot, "data/replay/output");
-  await import_promises4.default.mkdir(outputDir, { recursive: true });
+  const outputDir = import_node_path2.default.resolve(projectRoot, "data/replay/output");
+  await import_promises2.default.mkdir(outputDir, { recursive: true });
   const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
   const report = {
     reportType: "replay-output",
@@ -9022,8 +8817,8 @@ var writeReplayOutputReport = async ({
     runtimeComparison,
     perTradeAnalysis
   };
-  const markdownPath = import_node_path4.default.join(outputDir, `${timestamp}-replay-report.md`);
-  const jsonPath = import_node_path4.default.join(outputDir, `${timestamp}-replay-report.json`);
+  const markdownPath = import_node_path2.default.join(outputDir, `${timestamp}-replay-report.md`);
+  const jsonPath = import_node_path2.default.join(outputDir, `${timestamp}-replay-report.json`);
   const lines = [
     "# Replay Report",
     "",
@@ -9089,8 +8884,8 @@ var writeReplayOutputReport = async ({
     ""
   ];
   await Promise.all([
-    import_promises4.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-    import_promises4.default.writeFile(jsonPath, `${(0, import_data.toJson)(report, true)}
+    import_promises2.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+    import_promises2.default.writeFile(jsonPath, `${(0, import_data.toJson)(report, true)}
 `, "utf8")
   ]);
   return {