@tradejs/cli 2.0.6 → 2.0.8

package/dist/scripts/replay.js

@@ -1643,8 +1643,9 @@ module.exports = __toCommonJS(replay_exports);
 // src/scripts/replayRunner.ts
 var import_chalk12 = __toESM(require("chalk"));
 var import_constants6 = require("@tradejs/core/constants");
+var import_data2 = require("@tradejs/core/data");
 var import_time7 = require("@tradejs/core/time");
-var import_redis5 = require("@tradejs/infra/redis");
+var import_redis6 = require("@tradejs/infra/redis");
 
 // src/lib/runFormatting.ts
 var import_date_fns = require("date-fns");
@@ -1706,11 +1707,30 @@ var resolveTimeWindow = ({
   endTime,
   nowMs = Date.now(),
   defaultStartMs,
-  defaultEndMs
+  defaultEndMs,
+  closedIntervalMs
 }) => {
   const explicitStart = toEpochMs(startTime);
   const explicitEnd = toEpochMs(endTime);
   const resolvedDays = toPositiveNumber(days);
+  const alignToLastClosedInterval = (window2, preserveDuration) => {
+    if (typeof closedIntervalMs !== "number" || !Number.isFinite(closedIntervalMs) || closedIntervalMs <= 0) {
+      return window2;
+    }
+    const alignedEnd = Math.floor(window2.end / closedIntervalMs) * closedIntervalMs - 1;
+    const delta = window2.end - alignedEnd;
+    const alignedStart = preserveDuration ? window2.start - delta : window2.start;
+    if (alignedStart >= alignedEnd) {
+      throw new Error(
+        `Invalid closed-candle window: start (${alignedStart}) must be less than end (${alignedEnd})`
+      );
+    }
+    return {
+      ...window2,
+      start: Math.trunc(alignedStart),
+      end: Math.trunc(alignedEnd)
+    };
+  };
   if (explicitStart != null || explicitEnd != null) {
     const resolvedStart = explicitStart ?? (resolvedDays != null && explicitEnd != null ? explicitEnd - resolvedDays * ONE_DAY_MS : defaultStartMs);
     const resolvedEnd2 = explicitEnd ?? (resolvedDays != null && explicitStart != null ? explicitStart + resolvedDays * ONE_DAY_MS : defaultEndMs ?? nowMs);
@@ -1719,11 +1739,14 @@ var resolveTimeWindow = ({
         `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
       );
     }
-    return {
-      start: resolvedStart,
-      end: resolvedEnd2,
-      source: "explicit"
-    };
+    return alignToLastClosedInterval(
+      {
+        start: resolvedStart,
+        end: resolvedEnd2,
+        source: "explicit"
+      },
+      explicitStart == null && resolvedDays != null
+    );
   }
   if (resolvedDays != null) {
     const resolvedEnd2 = defaultEndMs ?? nowMs;
@@ -1733,11 +1756,14 @@ var resolveTimeWindow = ({
         `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
       );
     }
-    return {
-      start: Math.trunc(resolvedStart),
-      end: Math.trunc(resolvedEnd2),
-      source: "days"
-    };
+    return alignToLastClosedInterval(
+      {
+        start: Math.trunc(resolvedStart),
+        end: Math.trunc(resolvedEnd2),
+        source: "days"
+      },
+      true
+    );
   }
   const resolvedEnd = defaultEndMs ?? nowMs;
   if (defaultStartMs >= resolvedEnd) {
@@ -1745,11 +1771,14 @@ var resolveTimeWindow = ({
       `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
     );
   }
-  return {
-    start: Math.trunc(defaultStartMs),
-    end: Math.trunc(resolvedEnd),
-    source: "default"
-  };
+  return alignToLastClosedInterval(
+    {
+      start: Math.trunc(defaultStartMs),
+      end: Math.trunc(resolvedEnd),
+      source: "default"
+    },
+    true
+  );
 };
 
 // src/lib/runtimeStrategyBacktest.ts
@@ -2189,7 +2218,8 @@ var prepareRunEnvironment = async ({
   accountId,
   deploymentId,
   assetClasses,
-  deployment
+  deployment,
+  closedIntervalMs
 }) => {
   const connectorName = await resolveRunConnectorName({
     value: connector,
@@ -2252,7 +2282,8 @@ var prepareRunEnvironment = async ({
     startTime,
     endTime,
     defaultStartMs: (0, import_time2.getTimestamp)(import_constants.BACKTEST_DEFAULT_DAYS),
-    defaultEndMs: (0, import_time2.getTimestamp)()
+    defaultEndMs: (0, import_time2.getTimestamp)(),
+    closedIntervalMs
   });
   const preloadStart = (0, import_time2.getBacktestPreloadStart)(
     window2.start,
@@ -2321,6 +2352,7 @@ var import_progress = __toESM(require("progress"));
 var import_chalk4 = __toESM(require("chalk"));
 var import_connectors4 = require("@tradejs/connectors");
 var import_connectors5 = require("@tradejs/node/connectors");
+var import_strategies = require("@tradejs/node/strategies");
 var import_timescale = require("@tradejs/infra/timescale");
 
 // src/lib/binanceMarketData.ts
@@ -2330,14 +2362,6 @@ var MARKET_FEATURE_INTERVAL_MS = {
   "15m": 9e5,
   "1h": 36e5
 };
-var STABLE_QUOTE_SYMBOLS = /* @__PURE__ */ new Set([
-  "USDCUSDT",
-  "FDUSDUSDT",
-  "TUSDUSDT",
-  "BUSDUSDT",
-  "USDPUSDT",
-  "DAIUSDT"
-]);
 var safeDivide = (num, den) => Number.isFinite(num) && Number.isFinite(den) && den !== 0 ? num / den : null;
 var mean = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
 var standardDeviation = (values) => {
@@ -2381,9 +2405,6 @@ var classifyBtcAltRegime = ({
   if (btcVsAltReturn24h < -5e-3) return "alt_lead";
   return "neutral";
 };
-var selectBreadthUniverseFromTickers = (tickers, limit) => tickers.filter(
-  (ticker) => ticker.symbol.endsWith("USDT") && ticker.symbol !== "BTCUSDT" && !STABLE_QUOTE_SYMBOLS.has(ticker.symbol) && Number.isFinite(ticker.turnover24h) && ticker.turnover24h > 0
-).sort((a, b) => b.turnover24h - a.turnover24h).slice(0, Math.max(0, limit)).map((ticker) => ticker.symbol);
 var aggregateAggTradesToRows = ({
   symbol,
   interval,
@@ -2865,10 +2886,6 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     process.env.BINANCE_MARKET_CONTEXT_TRADE_FLOW_SYMBOL_LIMIT,
     2
   );
-  const breadthLimit = asInt(
-    process.env.BINANCE_MARKET_CONTEXT_BREADTH_LIMIT,
-    30
-  );
   const breadthChunkDays = asFloat(
     process.env.BINANCE_MARKET_CONTEXT_BREADTH_CHUNK_DAYS,
     30
@@ -2991,88 +3008,113 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     }
   }
   if (includeBreadth) {
-    const tickers = await connector.getTickers();
-    const breadthSymbols = selectBreadthUniverseFromTickers(
-      tickers,
-      breadthLimit
-    );
-    const universe = `binance_top${breadthSymbols.length}_usdt`;
-    const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
-      universe,
-      interval,
-      startMs: breadthStartMs,
-      endMs
-    });
-    const hasBtcAltMetrics = (coverage?.btcAltMetricsRows ?? 0) >= Math.floor(Math.max(1, coverage?.rows ?? 0) * 0.9);
-    if (!hasCoverage({
-      coverage,
+    const breadthUniverses = (0, import_strategies.getBinanceBreadthUniverses)();
+    const breadthSymbols = breadthUniverses.at(-1)?.symbols ?? [];
+    const connectorInterval = marketIntervalToConnectorInterval(interval);
+    const chunks = buildBreadthBackfillChunks({
       startMs: breadthStartMs,
       endMs,
-      intervalMs
-    }) || !hasBtcAltMetrics) {
-      const connectorInterval = marketIntervalToConnectorInterval(interval);
-      const chunks = buildBreadthBackfillChunks({
-        startMs: breadthStartMs,
-        endMs,
-        intervalMs,
-        chunkDays: breadthChunkDays
-      });
-      const missingChunks = filterMissingBreadthBackfillChunks({
-        chunks,
-        coverage,
-        intervalMs
-      });
-      const bar = new import_progress.default(
-        "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
-        {
-          total: Math.max(1, missingChunks.length * breadthSymbols.length),
-          width: 24
-        }
-      );
-      let candlesRead = 0;
-      let skippedBreadthChunks = chunks.length - missingChunks.length;
-      if (!missingChunks.length) {
-        bar.tick(1, {
-          candles: 0,
-          skip: skippedBreadthChunks,
-          chunk: "cached",
-          symbol: universe
+      intervalMs,
+      chunkDays: breadthChunkDays
+    });
+    const plans = await Promise.all(
+      breadthUniverses.map(async (definition) => {
+        const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
+          universe: definition.universe,
+          interval,
+          startMs: breadthStartMs,
+          endMs
         });
-      }
-      for (let chunkIndex = 0; chunkIndex < missingChunks.length; chunkIndex += 1) {
-        const chunk = missingChunks[chunkIndex];
-        const originalChunkIndex = chunks.findIndex(
-          (item) => item.startMs === chunk.startMs && item.endMs === chunk.endMs
-        );
-        const candlesBySymbol = {};
-        for (const symbol of breadthSymbols) {
-          const candles = await connector.kline({
-            symbol,
-            interval: connectorInterval,
-            start: chunk.fetchStartMs,
-            end: chunk.endMs,
-            silent: true
-          });
-          candlesBySymbol[symbol] = candles;
-          candlesRead += candles.length;
-          bar.tick(1, {
-            candles: candlesRead,
-            skip: skippedBreadthChunks,
-            chunk: `${originalChunkIndex + 1}/${chunks.length}`,
-            symbol
-          });
+        const hasBtcAltMetrics = (coverage?.btcAltMetricsRows ?? 0) >= Math.floor(Math.max(1, coverage?.rows ?? 0) * 0.9);
+        const missingChunks2 = !hasCoverage({
+          coverage,
+          startMs: breadthStartMs,
+          endMs,
+          intervalMs
+        }) || !hasBtcAltMetrics ? !hasBtcAltMetrics ? chunks : filterMissingBreadthBackfillChunks({
+          chunks,
+          coverage,
+          intervalMs
+        }) : [];
+        if (!missingChunks2.length) {
+          console.log(
+            import_chalk4.default.gray(`breadth cached: universe=${definition.universe}`)
+          );
         }
-        const btcCandles = await connector.kline({
-          symbol: "BTCUSDT",
+        return {
+          definition,
+          missingChunkKeys: new Set(
+            missingChunks2.map((chunk) => `${chunk.startMs}:${chunk.endMs}`)
+          )
+        };
+      })
+    );
+    const missingChunks = chunks.filter((chunk) => {
+      const key = `${chunk.startMs}:${chunk.endMs}`;
+      return plans.some((plan) => plan.missingChunkKeys.has(key));
+    });
+    const bar = new import_progress.default(
+      "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
+      {
+        total: Math.max(1, missingChunks.length * breadthSymbols.length),
+        width: 24
+      }
+    );
+    let candlesRead = 0;
+    const skippedBreadthChunks = chunks.length - missingChunks.length;
+    if (!missingChunks.length) {
+      bar.tick(1, {
+        candles: 0,
+        skip: skippedBreadthChunks,
+        chunk: "cached",
+        symbol: "top5/top10/top30/top50/top100"
+      });
+    }
+    for (let chunkIndex = 0; chunkIndex < missingChunks.length; chunkIndex += 1) {
+      const chunk = missingChunks[chunkIndex];
+      const originalChunkIndex = chunks.findIndex(
+        (item) => item.startMs === chunk.startMs && item.endMs === chunk.endMs
+      );
+      const candlesBySymbol = {};
+      for (const symbol of breadthSymbols) {
+        const candles = await connector.kline({
+          symbol,
           interval: connectorInterval,
           start: chunk.fetchStartMs,
           end: chunk.endMs,
           silent: true
         });
+        candlesBySymbol[symbol] = candles;
+        candlesRead += candles.length;
+        bar.tick(1, {
+          candles: candlesRead,
+          skip: skippedBreadthChunks,
+          chunk: `${originalChunkIndex + 1}/${chunks.length}`,
+          symbol
+        });
+      }
+      const btcCandles = await connector.kline({
+        symbol: "BTCUSDT",
+        interval: connectorInterval,
+        start: chunk.fetchStartMs,
+        end: chunk.endMs,
+        silent: true
+      });
+      const chunkKey = `${chunk.startMs}:${chunk.endMs}`;
+      for (const plan of plans) {
+        if (!plan.missingChunkKeys.has(chunkKey)) {
+          continue;
+        }
+        const symbolSet = new Set(plan.definition.symbols);
+        const universeCandles = Object.fromEntries(
+          Object.entries(candlesBySymbol).filter(
+            ([symbol]) => symbolSet.has(symbol)
+          )
+        );
         const rows = buildMarketBreadthRows({
-          universe,
+          universe: plan.definition.universe,
           interval,
-          candlesBySymbol,
+          candlesBySymbol: universeCandles,
           btcCandles
         }).filter((row) => {
           const ts = row.ts.getTime();
@@ -3081,8 +3123,6 @@ var backfillBinanceMarketContext = async (params, enabled) => {
         await (0, import_timescale.upsertMarketBreadthRows)(rows);
         breadthRows += rows.length;
       }
-    } else {
-      console.log(import_chalk4.default.gray(`breadth cached: universe=${universe}`));
     }
   }
   console.log(
@@ -4307,27 +4347,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-var getCoinMarketCapPathLabel = (path2) => {
-  if (path2.includes("global-metrics")) return "global";
-  if (path2.includes("cryptocurrency/quotes")) return "reference";
-  if (path2.includes("exchange/quotes")) return "exchangeLiquidity";
-  if (path2.includes("fear-and-greed")) return "fearGreed";
-  if (path2.includes("cmc100")) return "cmc100";
-  if (path2.includes("cmc20")) return "cmc20";
-  return path2;
-};
-var recordCoinMarketCapFetchStats = (stats, path2, 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(path2) ?? { 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(path2, existing);
+  stats.byPath.set(path3, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path2, item]) => `${getCoinMarketCapPathLabel(path2)}=${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}` : ""}`;
 };
@@ -5243,8 +5283,12 @@ var prepareMarketContextForRun = async (params) => {
 };
 
 // src/lib/backtest/runState.ts
+var import_types = require("@tradejs/types");
 var successTests = 0;
 var errorTests = 0;
+var warningCounts = {
+  [import_types.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY]: 0
+};
 var errorMessages = [];
 var topResults = [];
 var bestTickerResults = /* @__PURE__ */ new Map();
@@ -5289,6 +5333,9 @@ var getRuntimeCompareContext = () => ({
 var resetRunState = () => {
   successTests = 0;
   errorTests = 0;
+  for (const code of Object.values(import_types.BACKTEST_WARNING_CODES)) {
+    warningCounts[code] = 0;
+  }
   errorMessages.length = 0;
   topResults = [];
   bestTickerResults.clear();
@@ -5433,13 +5480,16 @@ var REPLAY_RUNTIME_COMPARISON_HEADERS = [
   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.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
@@ -5504,12 +5554,13 @@ var compactReplaySignal = (signal) => {
 var import_chalk9 = __toESM(require("chalk"));
 var import_progress3 = __toESM(require("progress"));
 var import_backtest = require("@tradejs/core/backtest");
-var import_strategies = require("@tradejs/core/strategies");
+var import_strategies2 = 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_strategies2 = require("@tradejs/node/strategies");
+var import_strategies3 = require("@tradejs/node/strategies");
 
 // src/lib/replay/portfolioReplayConnector.ts
 var import_constants3 = require("@tradejs/core/constants");
@@ -5959,21 +6010,231 @@ var invokeAfterSignalsHooks = async (hooks, params) => {
   }
 };
 
+// src/lib/runtimeLineage.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+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"
+];
+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
+};
+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 fingerprintRuntimeValue = (value) => (0, import_node_crypto.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 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_promises.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_path.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 resolveGateFingerprint = async ({
+  projectRoot,
+  strategyName,
+  gitSha
+}) => {
+  const cacheKey = `${projectRoot}:${strategyName}:${gitSha ?? "unknown"}`;
+  const cached = gateFingerprintCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const relativeCandidates = [
+    `packages/strategies/src/${strategyName}/adapters/ai.ts`,
+    `packages/strategies/src/${strategyName}/guardrails.ts`,
+    `packages/strategies/src/${strategyName}/pockets.ts`,
+    `packages/strategies/src/${strategyName}/config.ts`,
+    "packages/node/src/ai.ts"
+  ];
+  const optionalEntries = await Promise.all(
+    relativeCandidates.map(async (relativePath) => {
+      const content = await readOptionalFile(
+        import_node_path.default.join(projectRoot, relativePath)
+      );
+      return content == null ? null : { relativePath, content };
+    })
+  );
+  const sourceEntries = [];
+  for (const entry of optionalEntries) {
+    if (entry != null) {
+      sourceEntries.push(entry);
+    }
+  }
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  const fingerprint = hash.digest("hex").slice(0, 16);
+  gateFingerprintCache.set(cacheKey, fingerprint);
+  return fingerprint;
+};
+var buildRuntimeLineage = async ({
+  projectRoot,
+  strategyName,
+  config,
+  runContext,
+  env = process.env
+}) => {
+  const git = resolveGitLineage(projectRoot);
+  const context = {
+    ...Object.fromEntries(
+      RUNTIME_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
+    ),
+    ...RUNTIME_CONTEXT_DATA_MODEL,
+    binanceBreadthUniverseFingerprint: await resolveBinanceBreadthFingerprint(projectRoot),
+    ...runContext
+  };
+  return {
+    schemaVersion: 1,
+    ...git,
+    gateFingerprint: await resolveGateFingerprint({
+      projectRoot,
+      strategyName,
+      gitSha: git.gitSha
+    }),
+    configFingerprint: fingerprintRuntimeValue(config),
+    contextFingerprint: fingerprintRuntimeValue(context)
+  };
+};
+var runtimeLineageKey = (lineage) => [
+  lineage.schemaVersion,
+  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);
+
 // src/lib/replay/historicalSignalsReplay.ts
 var loadRuntimeStrategies = async (runtimeStrategies) => {
   const strategies = await Promise.all(
     runtimeStrategies.map(async ({ strategyName, strategyConfig }) => {
-      const strategyCreator = await (0, import_strategies2.getStrategyCreator)(
+      const strategyCreator = await (0, import_strategies3.getStrategyCreator)(
         strategyName,
         replayProjectRoot
       );
       if (!strategyCreator) {
         throw new Error(`Unknown strategy: ${strategyName}`);
       }
+      const strategyResults = await (0, import_redis3.getData)(
+        import_redis3.redisKeys.strategyResults(replayUserName, strategyName),
+        {}
+      );
       return {
         strategyName,
         strategyCreator,
-        strategyConfig
+        strategyConfig,
+        strategyResults
       };
     })
   );
@@ -6074,6 +6335,7 @@ var runHistoricalSignalsReplay = async ({
 }) => {
   const startedAt = Date.now();
   const signals = [];
+  const runtimeLineages = [];
   const projectConfig = await (0, import_cli4.loadTradejsConfig)(replayProjectRoot);
   const projectHooks = projectConfig.hooks;
   const loadedStrategies = await loadRuntimeStrategies(runtimeStrategies);
@@ -6161,26 +6423,54 @@ var runHistoricalSignalsReplay = async ({
     sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
     const strategiesForSymbol = await Promise.all(
       loadedStrategies.map(
-        async ({ strategyName, strategyCreator, strategyConfig }) => ({
+        async ({
           strategyName,
+          strategyCreator,
           strategyConfig,
-          run: await strategyCreator({
-            userName: replayUserName,
-            connectorName,
-            config: buildReplayStrategyConfig({
+          strategyResults
+        }) => {
+          const runtimeLineage = await buildRuntimeLineage({
+            projectRoot: replayProjectRoot,
+            strategyName,
+            config: {
+              configId: "config",
               strategyConfig,
-              interval
-            }),
+              symbolResultConfig: strategyResults?.[symbol]?.config ?? null
+            },
+            runContext: {
+              connectorName: connectorName.toLowerCase(),
+              interval: String(interval),
+              universe: preparedRun.universe ?? null
+            }
+          });
+          runtimeLineages.push({
+            strategy: strategyName,
             symbol,
-            data: preparedData.prevData,
-            btcData: preparedData.btcPrevData,
-            ethData: preparedData.ethPrevData,
-            btcBinanceData: preparedData.btcBinancePrevData,
-            btcCoinbaseData: preparedData.btcCoinbasePrevData,
-            connector: replayConnector,
-            sharedIndicatorsReplayKey
-          })
-        })
+            lineage: runtimeLineage
+          });
+          return {
+            strategyName,
+            strategyConfig,
+            runtimeLineage,
+            run: await strategyCreator({
+              userName: replayUserName,
+              connectorName,
+              runtimeConfigId: "config",
+              config: buildReplayStrategyConfig({
+                strategyConfig,
+                interval
+              }),
+              symbol,
+              data: preparedData.prevData,
+              btcData: preparedData.btcPrevData,
+              ethData: preparedData.ethPrevData,
+              btcBinanceData: preparedData.btcBinancePrevData,
+              btcCoinbaseData: preparedData.btcCoinbasePrevData,
+              connector: replayConnector,
+              sharedIndicatorsReplayKey
+            })
+          };
+        }
       )
     );
     const symbolRuntime = {
@@ -6274,7 +6564,8 @@ var runHistoricalSignalsReplay = async ({
             ethCandle?.timestamp === timestamp ? ethCandle : void 0
           );
           if (result && typeof result !== "string") {
-            await (0, import_strategies2.enrichSignalWithBinanceMarketContext)({
+            result.runtimeLineage = strategyRuntime.runtimeLineage;
+            await (0, import_strategies3.enrichSignalWithBinanceMarketContext)({
               signal: result,
               env: "PARITY"
             });
@@ -6298,8 +6589,8 @@ var runHistoricalSignalsReplay = async ({
     }
   } finally {
     for (const keyPrefix of sharedReplayKeyPrefixes) {
-      (0, import_strategies.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-      (0, import_strategies.releaseStrategyReplayCache)(keyPrefix);
+      (0, import_strategies2.releaseStrategyIndicatorsReplayCache)(keyPrefix);
+      (0, import_strategies2.releaseStrategyReplayCache)(keyPrefix);
     }
   }
   const artifacts = replayConnector.getReplayArtifacts();
@@ -6333,7 +6624,8 @@ var runHistoricalSignalsReplay = async ({
     orderLog: artifacts.orderLog,
     positionLog: artifacts.positionLog,
     cycleCount: orderedTimestamps.length,
-    abortedCycles
+    abortedCycles,
+    runtimeLineages
   };
 };
 
@@ -6817,7 +7109,7 @@ var summarizeTradeParityByStrategy = ({
 };
 
 // src/lib/runtimeSignalsLoader.ts
-var import_redis3 = require("@tradejs/infra/redis");
+var import_redis4 = require("@tradejs/infra/redis");
 
 // src/lib/runtimeSignalsStorage.ts
 var import_constants4 = require("@tradejs/core/constants");
@@ -6867,14 +7159,14 @@ var loadRuntimeSignals = async (userName, {
   startTime,
   endTime
 } = {}) => {
-  const bucketPrefix = import_redis3.redisKeys.runtimeSignalBuckets(userName);
+  const bucketPrefix = import_redis4.redisKeys.runtimeSignalBuckets(userName);
   const bucketKeys = filterBucketKeysByWindow(
-    await (0, import_redis3.getKeys)(bucketPrefix),
+    await (0, import_redis4.getKeys)(bucketPrefix),
     bucketPrefix,
     startTime,
     endTime
   );
-  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis3.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis4.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
   const seen = /* @__PURE__ */ new Set();
   const payloads = await Promise.all(
     refs.map(async (ref) => {
@@ -6883,8 +7175,8 @@ var loadRuntimeSignals = async (userName, {
         return null;
       }
       seen.add(dedupeKey);
-      const signal = await (0, import_redis3.getData)(
-        import_redis3.redisKeys.storeSignal(ref.symbol, ref.signalId),
+      const signal = await (0, import_redis4.getData)(
+        import_redis4.redisKeys.storeSignal(ref.symbol, ref.signalId),
         null
       );
       return isSignalRecord(signal) ? signal : null;
@@ -6896,25 +7188,42 @@ var loadRuntimeSignalEvaluations = async (userName, {
   startTime,
   endTime
 } = {}) => {
-  const bucketPrefix = import_redis3.redisKeys.runtimeSignalEvaluationBuckets(userName);
+  const bucketPrefix = import_redis4.redisKeys.runtimeSignalEvaluationBuckets(userName);
   const bucketKeys = filterBucketKeysByWindow(
-    await (0, import_redis3.getKeys)(bucketPrefix),
+    await (0, import_redis4.getKeys)(bucketPrefix),
     bucketPrefix,
     startTime,
     endTime
   );
-  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis3.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis4.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
   const deduped = /* @__PURE__ */ new Map();
   for (const evaluation of evaluations) {
     deduped.set(evaluation.evaluationId, evaluation);
   }
   return sortByTimestamp([...deduped.values()]);
 };
+var loadRuntimeLineageScopes = async (userName, {
+  startTime,
+  endTime
+}) => {
+  const records = (await Promise.all(
+    (0, import_time4.getRuntimeStorageDayKeys)(startTime, endTime).map(
+      (dayKey) => (0, import_redis4.getHashJsonValues)(
+        import_redis4.redisKeys.runtimeLineageScopeBucket(userName, dayKey)
+      )
+    )
+  )).flat().filter(
+    (record) => record != null && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.firstTimestamp === "number" && typeof record.lastTimestamp === "number" && record.lineage != null
+  );
+  return records.sort(
+    (left, right) => left.firstTimestamp - right.firstTimestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol)
+  );
+};
 
 // src/lib/runtimeTradeSync.ts
 var import_constants5 = require("@tradejs/core/constants");
 var import_time5 = require("@tradejs/core/time");
-var import_redis4 = require("@tradejs/infra/redis");
+var import_redis5 = require("@tradejs/infra/redis");
 var CLOSED_PNL_LIMIT = 100;
 var CLOSED_PNL_RECONCILIATION_LOOKBACK_MS = 24 * 60 * 60 * 1e3;
 var EXCHANGE_HISTORY_MAX_RANGE_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -7008,6 +7317,18 @@ var consumeClosedPnlMatch = (buckets, trade) => {
   const [row] = rows.splice(matchIndex, 1);
   return row ?? null;
 };
+var isRuntimeTradeInConnectorScope = (trade, connector) => {
+  if (trade.deploymentId && trade.deploymentId !== connector.deploymentId) {
+    return false;
+  }
+  if (trade.accountId && trade.accountId !== connector.accountId) {
+    return false;
+  }
+  if (trade.universe && connector.universe && trade.universe !== connector.universe) {
+    return false;
+  }
+  return true;
+};
 var syncRuntimeTrades = async ({
   userName,
   connector,
@@ -7031,16 +7352,23 @@ var syncRuntimeTrades = async ({
   const openPositionsBySymbol = new Map(
     openPositions.map((position) => [position.symbol, position])
   );
-  const activeOrderIdBySymbol = /* @__PURE__ */ new Map();
-  const symbols = [...new Set(trades.map((trade) => trade.symbol))];
+  const activeOrderIdByKey = /* @__PURE__ */ new Map();
+  const activeTradeKeys = [
+    ...new Set(
+      trades.filter((trade) => isRuntimeTradeInConnectorScope(trade, connector)).map(
+        (trade) => import_redis5.redisKeys.runtimeActiveTrade(
+          userName,
+          trade.symbol,
+          trade.deploymentId ?? trade.accountId
+        )
+      )
+    )
+  ];
   await Promise.all(
-    symbols.map(async (symbol) => {
-      const activeRef = await (0, import_redis4.getData)(
-        import_redis4.redisKeys.runtimeActiveTrade(userName, symbol),
-        null
-      );
-      activeOrderIdBySymbol.set(
-        symbol,
+    activeTradeKeys.map(async (key) => {
+      const activeRef = await (0, import_redis5.getData)(key, null);
+      activeOrderIdByKey.set(
+        key,
         typeof activeRef?.orderId === "string" ? activeRef.orderId : null
       );
     })
@@ -7059,12 +7387,21 @@ var syncRuntimeTrades = async ({
   }
   const syncedTrades = [];
   for (const trade of trades) {
+    if (!isRuntimeTradeInConnectorScope(trade, connector)) {
+      syncedTrades.push(trade);
+      continue;
+    }
     if (trade.status !== "active" && !isRuntimeTradeSyncFallbackClose(trade)) {
       syncedTrades.push(trade);
       continue;
     }
+    const activeTradeKey = import_redis5.redisKeys.runtimeActiveTrade(
+      userName,
+      trade.symbol,
+      trade.deploymentId ?? trade.accountId
+    );
     const openPosition = openPositionsBySymbol.get(trade.symbol);
-    const activeOrderId = activeOrderIdBySymbol.get(trade.symbol);
+    const activeOrderId = activeOrderIdByKey.get(activeTradeKey);
     const isCurrentActiveTrade = activeOrderId === trade.orderId;
     if (trade.status === "active" && !openPositionsReliable) {
       syncedTrades.push({
@@ -7082,15 +7419,15 @@ var syncRuntimeTrades = async ({
         currentPnl: openPosition.unrealizedPnl,
         lastSyncedAt: endTime
       };
-      await (0, import_redis4.setData)(
-        import_redis4.redisKeys.runtimeTrade(userName, trade.orderId),
+      await (0, import_redis5.setData)(
+        import_redis5.redisKeys.runtimeTrade(userName, trade.orderId),
         nextTrade2,
         {
           expire: 0
         }
       );
-      await (0, import_redis4.setHashJsonField)(
-        import_redis4.redisKeys.runtimeTradeBucket(
+      await (0, import_redis5.setHashJsonField)(
+        import_redis5.redisKeys.runtimeTradeBucket(
           userName,
           (0, import_time5.getRuntimeStorageDayKey)(trade.entryTimestamp)
         ),
@@ -7103,6 +7440,7 @@ var syncRuntimeTrades = async ({
     }
     const matchedClosedPnl = consumeClosedPnlMatch(closedPnlBuckets, trade);
     if (!matchedClosedPnl) {
+      syncedTrades.push(trade);
       continue;
     }
     const nextTrade = {
@@ -7123,11 +7461,11 @@ var syncRuntimeTrades = async ({
       lastSyncedAt: endTime
     };
     await Promise.all([
-      (0, import_redis4.setData)(import_redis4.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
+      (0, import_redis5.setData)(import_redis5.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
         expire: import_constants5.TTL_1M
       }),
-      (0, import_redis4.setHashJsonField)(
-        import_redis4.redisKeys.runtimeTradeBucket(
+      (0, import_redis5.setHashJsonField)(
+        import_redis5.redisKeys.runtimeTradeBucket(
           userName,
           (0, import_time5.getRuntimeStorageDayKey)(trade.entryTimestamp)
         ),
@@ -7135,7 +7473,7 @@ var syncRuntimeTrades = async ({
         nextTrade,
         { expire: import_constants5.TTL_1M }
       ),
-      ...isCurrentActiveTrade ? [(0, import_redis4.delKey)(import_redis4.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
+      ...isCurrentActiveTrade ? [(0, import_redis5.delKey)(activeTradeKey)] : []
     ]);
     syncedTrades.push(nextTrade);
   }
@@ -7745,6 +8083,7 @@ var buildReplayRuntimeComparisonDetails = ({
       ),
       limit
     ),
+    orderFailed: [],
     runtimeOnly: cappedRuntimeOnlyDetails,
     backtestOnly: cappedBacktestOnlyDetails,
     nearestCandidates: cappedNearestCandidates,
@@ -7764,6 +8103,7 @@ var buildReplayRuntimeComparisonDetails = ({
 };
 var buildReplayExchangeComparisonDetails = ({
   matched,
+  orderFailed = [],
   exchangeOnly,
   backtestOnly,
   exchangeEntries,
@@ -7814,7 +8154,7 @@ var buildReplayExchangeComparisonDetails = ({
     limit
   );
   return {
-    capped: matched.length > limit || exchangeOnlyDetails.length > limit || backtestOnlyDetails.length > limit || nearestCandidates.length > limit,
+    capped: matched.length > limit || orderFailed.length > limit || exchangeOnlyDetails.length > limit || backtestOnlyDetails.length > limit || nearestCandidates.length > limit,
     limit,
     matched: capReplayDetails(
       matched.map(
@@ -7830,6 +8170,27 @@ var buildReplayExchangeComparisonDetails = ({
       ),
       limit
     ),
+    orderFailed: capReplayDetails(
+      orderFailed.map((item) => {
+        const detail = buildMatchedReplayDetail({
+          runtime: toExchangeDetail(item.exchange),
+          backtest: toBacktestParityDetail(
+            item.backtest,
+            backtestTimestampOffsetMs
+          ),
+          timestampDiffMs: item.timestampDiffMs,
+          priceDeltaPct: item.priceDeltaPct
+        });
+        return {
+          runtime: detail.runtime,
+          backtest: detail.backtest,
+          timestampDiffMs: detail.timestampDiffMs,
+          priceDeltaPct: detail.priceDeltaPct,
+          reason: item.reason
+        };
+      }),
+      limit
+    ),
     runtimeOnly: cappedExchangeOnlyDetails,
     backtestOnly: cappedBacktestOnlyDetails,
     nearestCandidates: cappedNearestCandidates,
@@ -7865,11 +8226,147 @@ var buildReplaySignalEvaluations = (signals) => signals.map((signal) => ({
   reason: signal.orderSkipReason || signal.orderStatus || "SIGNAL",
   signalId: signal.signalId,
   direction: signal.direction,
+  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 buildExpectedLineageByScope = (replayLineages) => new Map(
+  replayLineages.map((record) => [
+    lineageScopeKey(record.strategy, record.symbol),
+    record.lineage
+  ])
+);
+var hasExpectedLineage = ({
+  strategy,
+  symbol,
+  lineage,
+  expectedByScope
+}) => runtimeLineagesMatch(
+  lineage,
+  expectedByScope.get(lineageScopeKey(strategy, symbol))
+);
+var filterReplayComparisonByLineage = ({
+  replayLineages,
+  runtimeTrades,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  runtimeLineageScopes,
+  backtestEntries
+}) => {
+  const expectedByScope = buildExpectedLineageByScope(replayLineages);
+  const comparableRuntimeSignals = runtimeSignals.filter(
+    (signal) => hasExpectedLineage({
+      strategy: signal.strategy,
+      symbol: signal.symbol,
+      lineage: signal.runtimeLineage,
+      expectedByScope
+    })
+  );
+  const comparableRuntimeEvaluations = runtimeSignalEvaluations.filter(
+    (evaluation) => hasExpectedLineage({
+      strategy: evaluation.strategy,
+      symbol: evaluation.symbol,
+      lineage: evaluation.runtimeLineage,
+      expectedByScope
+    })
+  );
+  const comparableRuntimeLineageScopes = runtimeLineageScopes.filter(
+    (scope) => hasExpectedLineage({
+      strategy: scope.strategy,
+      symbol: scope.symbol,
+      lineage: scope.lineage,
+      expectedByScope
+    })
+  );
+  const deploymentWindows = /* @__PURE__ */ new Map();
+  for (const scope of comparableRuntimeLineageScopes) {
+    const key = lineageScopeKey(scope.strategy, scope.symbol);
+    const existing = deploymentWindows.get(key);
+    deploymentWindows.set(key, {
+      firstTimestamp: existing == null ? scope.firstTimestamp : Math.min(existing.firstTimestamp, scope.firstTimestamp),
+      lastTimestamp: existing == null ? scope.lastTimestamp : Math.max(existing.lastTimestamp, scope.lastTimestamp)
+    });
+  }
+  const lineageBySignalId = /* @__PURE__ */ new Map();
+  for (const signal of runtimeSignals) {
+    if (signal.runtimeLineage) {
+      lineageBySignalId.set(signal.signalId, signal.runtimeLineage);
+    }
+  }
+  for (const evaluation of runtimeSignalEvaluations) {
+    if (evaluation.signalId && evaluation.runtimeLineage) {
+      lineageBySignalId.set(evaluation.signalId, evaluation.runtimeLineage);
+    }
+  }
+  const comparableRuntimeTrades = runtimeTrades.filter((trade) => {
+    const lineage = trade.signalId ? lineageBySignalId.get(trade.signalId) : void 0;
+    if (lineage) {
+      return hasExpectedLineage({
+        strategy: trade.strategy,
+        symbol: trade.symbol,
+        lineage,
+        expectedByScope
+      });
+    }
+    const window2 = deploymentWindows.get(
+      lineageScopeKey(trade.strategy, trade.symbol)
+    );
+    const signalTimestamp = trade.signalTimestamp ?? trade.entryTimestamp;
+    return window2 != null && signalTimestamp >= window2.firstTimestamp && signalTimestamp <= window2.lastTimestamp;
+  });
+  for (const artifact of [
+    ...comparableRuntimeSignals,
+    ...comparableRuntimeEvaluations
+  ]) {
+    const key = lineageScopeKey(artifact.strategy, artifact.symbol);
+    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 comparableBacktestEntries = backtestEntries.filter((entry) => {
+    const window2 = deploymentWindows.get(
+      lineageScopeKey(entry.strategy, entry.symbol)
+    );
+    const signalTimestamp = entry.signalTimestamp ?? entry.timestamp;
+    return window2 != null && signalTimestamp >= window2.firstTimestamp && signalTimestamp <= window2.lastTimestamp;
+  });
+  const comparableScopeKeys = new Set(deploymentWindows.keys());
+  return {
+    runtimeTrades: comparableRuntimeTrades,
+    runtimeSignals: comparableRuntimeSignals,
+    runtimeSignalEvaluations: comparableRuntimeEvaluations,
+    backtestEntries: comparableBacktestEntries,
+    lineage: {
+      enforced: true,
+      replayScopes: expectedByScope.size,
+      comparableScopes: comparableScopeKeys.size,
+      excludedRuntimeTrades: runtimeTrades.length - comparableRuntimeTrades.length,
+      excludedRuntimeSignals: runtimeSignals.length - comparableRuntimeSignals.length,
+      excludedRuntimeEvaluations: runtimeSignalEvaluations.length - comparableRuntimeEvaluations.length,
+      excludedRuntimeLineageScopes: runtimeLineageScopes.length - comparableRuntimeLineageScopes.length,
+      excludedExchangeEntries: 0,
+      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("::");
+        return {
+          strategy: scope.slice(0, separator),
+          symbol: scope.slice(separator + 2),
+          lineage
+        };
+      }).sort(
+        (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || runtimeLineageKey(left.lineage).localeCompare(
+          runtimeLineageKey(right.lineage)
+        )
+      )
+    }
+  };
+};
 var formatDrilldownSummary = (summary) => Object.entries(summary).filter(([, count]) => count > 0).map(([classification, count]) => `${classification}=${count}`).join(", ");
 var toFiniteNumberOrNull4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var sumOptionalNumbers = (values) => {
@@ -7893,6 +8390,14 @@ var firstFiniteNumber = (values) => {
   return null;
 };
 var firstString = (values) => values.find((value) => typeof value === "string" && value.trim());
+var summarizeBacktestPnlByStrategy = (entries) => {
+  const totals = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const pnl = typeof entry.expectedPnl === "number" && Number.isFinite(entry.expectedPnl) ? entry.expectedPnl : 0;
+    totals.set(entry.strategy, (totals.get(entry.strategy) ?? 0) + pnl);
+  }
+  return totals;
+};
 var getExchangeExecutionMergeKey = (entry) => {
   const orderId = firstString([entry.orderId, entry.orderLinkId]);
   return orderId ? `${entry.symbol}::${entry.direction}::${orderId}` : null;
@@ -8159,16 +8664,89 @@ var compareExchangeEntriesToBacktest = ({
     backtestOnly
   };
 };
+var findExchangeRuntimeOutcome = ({
+  exchangeEntry,
+  strategyName,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  toleranceMs,
+  signalTimestampOffsetMs
+}) => {
+  const candidates = [];
+  for (const signal of runtimeSignals) {
+    if (signal.strategy === strategyName && signal.symbol === exchangeEntry.symbol && signal.direction === exchangeEntry.direction) {
+      candidates.push({
+        timestamp: signal.timestamp,
+        orderStatus: signal.orderStatus,
+        reason: signal.orderFailureReason || signal.orderSkipReason || signal.orderStatus
+      });
+    }
+  }
+  for (const evaluation of runtimeSignalEvaluations) {
+    if (evaluation.strategy === strategyName && evaluation.symbol === exchangeEntry.symbol && (evaluation.direction == null || evaluation.direction === exchangeEntry.direction)) {
+      candidates.push({
+        timestamp: evaluation.timestamp,
+        orderStatus: evaluation.orderStatus,
+        reason: evaluation.orderSkipReason || evaluation.reason || evaluation.orderStatus
+      });
+    }
+  }
+  return candidates.map((candidate) => ({
+    ...candidate,
+    timestampDiffMs: Math.abs(
+      candidate.timestamp + signalTimestampOffsetMs - exchangeEntry.entryTimestamp
+    )
+  })).filter((candidate) => candidate.timestampDiffMs <= toleranceMs).sort(
+    (left, right) => left.timestampDiffMs - right.timestampDiffMs || Number(right.orderStatus === "failed") - Number(left.orderStatus === "failed")
+  )[0] ?? null;
+};
+var splitExchangeMatchesByRuntimeOrderStatus = ({
+  matched,
+  strategyNameByOrderLinkKey,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  toleranceMs,
+  signalTimestampOffsetMs
+}) => {
+  const orderFailed = [];
+  const completed = matched.filter((item) => {
+    const strategyName = resolveReplayStrategyNameFromExchangeEntry({
+      exchangeEntry: item.exchange,
+      strategyNameByOrderLinkKey
+    });
+    if (!strategyName) {
+      return true;
+    }
+    const outcome = findExchangeRuntimeOutcome({
+      exchangeEntry: item.exchange,
+      strategyName,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      toleranceMs,
+      signalTimestampOffsetMs
+    });
+    if (outcome?.orderStatus !== "failed") {
+      return true;
+    }
+    orderFailed.push({
+      ...item,
+      reason: outcome.reason || "orderStatus=failed"
+    });
+    return false;
+  });
+  return { completed, orderFailed };
+};
 var saveAndPrintReplayExchangeComparison = async ({
   liveStrategySummaries,
   backtestEntries,
   replaySignals,
   replaySignalEvaluations,
   runtimeSignals,
-  runtimeSignalEvaluations
+  runtimeSignalEvaluations,
+  lineage
 }) => {
   const { connector, connectorName, window: window2 } = getRuntimeCompareContext();
-  const exchangeEntries = await loadExchangeEntriesForComparison({
+  const rawExchangeEntries = await loadExchangeEntriesForComparison({
     connector,
     startTime: window2.start,
     endTime: window2.end
@@ -8176,11 +8754,36 @@ var saveAndPrintReplayExchangeComparison = async ({
   const strategyNameByOrderLinkKey = buildStrategyNameByOrderLinkKey(
     liveStrategySummaries.map((summary) => summary.strategyName)
   );
+  const exchangeOutcomeByEntry = /* @__PURE__ */ new Map();
+  const exchangeEntries = rawExchangeEntries.filter((entry) => {
+    const strategyName = resolveReplayStrategyNameFromExchangeEntry({
+      exchangeEntry: entry,
+      strategyNameByOrderLinkKey
+    });
+    if (!strategyName) {
+      return false;
+    }
+    const outcome = findExchangeRuntimeOutcome({
+      exchangeEntry: entry,
+      strategyName,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
+      signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+    });
+    exchangeOutcomeByEntry.set(entry, outcome);
+    return outcome != null;
+  });
+  const comparisonLineage = {
+    ...lineage,
+    excludedExchangeEntries: lineage.excludedExchangeEntries + rawExchangeEntries.length - exchangeEntries.length
+  };
+  const backtestPnlByStrategy = summarizeBacktestPnlByStrategy(backtestEntries);
   if (!exchangeEntries.length) {
     console.log("");
     console.log(
       import_chalk11.default.yellow(
-        `SIGNALS REPLAY VS EXCHANGE: no exchange entry executions found for ${connectorName} in ${(0, import_time6.formatUnix)(
+        `SIGNALS REPLAY VS EXCHANGE: no lineage-linked exchange entry executions found for ${connectorName} in ${(0, import_time6.formatUnix)(
           window2.start
         )} -> ${(0, import_time6.formatUnix)(window2.end)}`
       )
@@ -8207,18 +8810,21 @@ var saveAndPrintReplayExchangeComparison = async ({
       runtimeEntriesCount: 0,
       backtestEntriesCount: backtestEntries.length,
       matchedCount: 0,
+      orderFailedCount: 0,
       runtimeOnlyCount: 0,
       backtestOnlyCount: backtestEntries.length,
       details: details2,
+      lineage: comparisonLineage,
       rows: liveStrategySummaries.map((summary) => ({
         strategyName: summary.strategyName,
         backtestEntries: backtestEntries.filter(
           (entry) => entry.strategy === summary.strategyName
         ).length,
-        backtestNetProfit: summary.netProfit,
+        backtestNetProfit: backtestPnlByStrategy.get(summary.strategyName) ?? 0,
         runtimeTrades: 0,
         runtimePnl: 0,
         matched: 0,
+        orderFailed: 0,
         runtimeOnly: 0,
         backtestOnly: backtestEntries.filter(
           (entry) => entry.strategy === summary.strategyName
@@ -8232,6 +8838,14 @@ var saveAndPrintReplayExchangeComparison = async ({
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
     backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
   });
+  const { completed: matched, orderFailed } = splitExchangeMatchesByRuntimeOrderStatus({
+    matched: comparison.matched,
+    strategyNameByOrderLinkKey,
+    runtimeSignals,
+    runtimeSignalEvaluations,
+    toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
+    signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+  });
   const liveSummaryByStrategy = new Map(
     liveStrategySummaries.map((summary) => [summary.strategyName, summary])
   );
@@ -8244,10 +8858,11 @@ var saveAndPrintReplayExchangeComparison = async ({
     const next = {
       strategyName,
       backtestEntries: 0,
-      backtestNetProfit: liveSummaryByStrategy.get(strategyName)?.netProfit ?? 0,
+      backtestNetProfit: backtestPnlByStrategy.get(strategyName) ?? 0,
       runtimeTrades: 0,
       runtimePnl: 0,
       matched: 0,
+      orderFailed: 0,
       runtimeOnly: 0,
       backtestOnly: 0
     };
@@ -8260,7 +8875,7 @@ var saveAndPrintReplayExchangeComparison = async ({
   for (const entry of backtestEntries) {
     ensureRow(entry.strategy).backtestEntries += 1;
   }
-  for (const item of comparison.matched) {
+  for (const item of matched) {
     const row = ensureRow(item.backtest.strategy);
     row.runtimeTrades += 1;
     row.matched += 1;
@@ -8268,6 +8883,11 @@ var saveAndPrintReplayExchangeComparison = async ({
       row.runtimePnl += item.exchange.closedPnl;
     }
   }
+  for (const item of orderFailed) {
+    const row = ensureRow(item.backtest.strategy);
+    row.runtimeTrades += 1;
+    row.orderFailed += 1;
+  }
   for (const entry of comparison.backtestOnly) {
     ensureRow(entry.strategy).backtestOnly += 1;
   }
@@ -8286,7 +8906,8 @@ var saveAndPrintReplayExchangeComparison = async ({
     }
   }
   const details = buildReplayExchangeComparisonDetails({
-    matched: comparison.matched,
+    matched,
+    orderFailed,
     exchangeOnly: comparison.exchangeOnly,
     backtestOnly: comparison.backtestOnly,
     exchangeEntries,
@@ -8313,8 +8934,10 @@ var saveAndPrintReplayExchangeComparison = async ({
       import_chalk11.default.yellow(String(row.runtimeTrades)),
       rtPnlColor(`${row.runtimePnl.toFixed(2)}$`),
       import_chalk11.default.green(String(row.matched)),
+      import_chalk11.default.red(String(row.orderFailed)),
       import_chalk11.default.yellow(String(row.runtimeOnly)),
-      import_chalk11.default.magenta(String(row.backtestOnly))
+      import_chalk11.default.magenta(String(row.backtestOnly)),
+      import_chalk11.default.red(String(getReplayRuntimeUnmatchedCount(row)))
     ];
   });
   console.log("");
@@ -8342,17 +8965,20 @@ var saveAndPrintReplayExchangeComparison = async ({
     windowTradesCount: exchangeEntries.length,
     runtimeEntriesCount: exchangeEntries.length,
     backtestEntriesCount: backtestEntries.length,
-    matchedCount: comparison.matched.length,
+    matchedCount: matched.length,
+    orderFailedCount: orderFailed.length,
     runtimeOnlyCount: comparison.exchangeOnly.length,
     backtestOnlyCount: comparison.backtestOnly.length,
     rows,
-    details
+    details,
+    lineage: comparisonLineage
   };
 };
 var saveAndPrintReplayRuntimeComparison = async ({
   liveStrategySummaries,
   backtestEntries,
-  replaySignals
+  replaySignals,
+  replayLineages
 }) => {
   const { connector, connectorName, window: window2 } = getRuntimeCompareContext();
   if (!connector || !window2) {
@@ -8362,8 +8988,16 @@ var saveAndPrintReplayRuntimeComparison = async ({
     liveStrategySummaries.map((summary) => summary.strategyName)
   );
   const replaySignalEvaluations = buildReplaySignalEvaluations(replaySignals);
-  const [rawRuntimeTrades, runtimeSignals, runtimeSignalEvaluations] = await Promise.all([
-    loadRuntimeTrades(replayUserName),
+  const [
+    rawRuntimeTrades,
+    runtimeSignals,
+    runtimeSignalEvaluations,
+    runtimeLineageScopes
+  ] = await Promise.all([
+    loadRuntimeTrades(replayUserName, {
+      startTime: window2.start,
+      endTime: window2.end
+    }),
     loadRuntimeSignals(replayUserName, {
       startTime: window2.start,
       endTime: window2.end
@@ -8371,6 +9005,10 @@ var saveAndPrintReplayRuntimeComparison = async ({
     loadRuntimeSignalEvaluations(replayUserName, {
       startTime: window2.start,
       endTime: window2.end
+    }),
+    loadRuntimeLineageScopes(replayUserName, {
+      startTime: window2.start,
+      endTime: window2.end
     })
   ]);
   const syncedRuntimeTrades = await syncRuntimeTrades({
@@ -8412,7 +9050,16 @@ var saveAndPrintReplayRuntimeComparison = async ({
       }
     }
   });
-  const windowRuntimeTrades = syncedRuntimeTrades.filter(
+  const comparable = filterReplayComparisonByLineage({
+    replayLineages,
+    runtimeTrades: syncedRuntimeTrades,
+    runtimeSignals,
+    runtimeSignalEvaluations,
+    runtimeLineageScopes,
+    backtestEntries
+  });
+  const comparableBacktestEntries = comparable.backtestEntries;
+  const windowRuntimeTrades = comparable.runtimeTrades.filter(
     (trade) => trade.entryTimestamp >= window2.start && trade.entryTimestamp < window2.end && relevantStrategies.has(trade.strategy)
   );
   if (!windowRuntimeTrades.length) {
@@ -8421,17 +9068,18 @@ var saveAndPrintReplayRuntimeComparison = async ({
       import_chalk11.default.yellow(
         `SIGNALS REPLAY VS RUNTIME: no local runtime trades found for ${connectorName} in ${(0, import_time6.formatUnix)(
           window2.start
-        )} -> ${(0, import_time6.formatUnix)(window2.end)}; falling back to direct exchange comparison`
+        )} -> ${(0, import_time6.formatUnix)(window2.end)} with matching lineage; checking lineage-linked exchange executions`
       )
     );
     console.log("");
     return saveAndPrintReplayExchangeComparison({
       liveStrategySummaries,
-      backtestEntries,
+      backtestEntries: comparableBacktestEntries,
       replaySignals,
       replaySignalEvaluations,
-      runtimeSignals,
-      runtimeSignalEvaluations
+      runtimeSignals: comparable.runtimeSignals,
+      runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
+      lineage: comparable.lineage
     });
   }
   const runtimeSummaries = summarizeRuntimeTradesByStrategy(windowRuntimeTrades);
@@ -8442,7 +9090,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   const runtimeDedupe = dedupeRuntimeParityEntries(rawRuntimeEntries);
   const comparison = compareTradeParityEntries({
     runtimeEntries: runtimeDedupe.entries,
-    backtestEntries,
+    backtestEntries: comparableBacktestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
     backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
   });
@@ -8451,18 +9099,18 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeOnly: comparison.runtimeOnly,
     backtestOnly: comparison.backtestOnly,
     runtimeEntries: runtimeDedupe.entries,
-    backtestEntries,
+    backtestEntries: comparableBacktestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
     backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
-    runtimeSignals,
-    runtimeSignalEvaluations,
+    runtimeSignals: comparable.runtimeSignals,
+    runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
     replaySignals,
     replaySignalEvaluations
   });
   const parityRows = summarizeTradeParityByStrategy({
     runtimeEntries: runtimeDedupe.entries,
     runtimeDuplicateEntries: runtimeDedupe.duplicateEntries,
-    backtestEntries,
+    backtestEntries: comparableBacktestEntries,
     matchedEntries: comparison.matched,
     runtimeOnlyEntries: comparison.runtimeOnly,
     backtestOnlyEntries: comparison.backtestOnly
@@ -8471,22 +9119,25 @@ var saveAndPrintReplayRuntimeComparison = async ({
   const liveSummaryByStrategy = new Map(
     liveStrategySummaries.map((summary) => [summary.strategyName, summary])
   );
+  const backtestPnlByStrategy = summarizeBacktestPnlByStrategy(
+    comparableBacktestEntries
+  );
   const strategyNames = /* @__PURE__ */ new Set([
     ...liveSummaryByStrategy.keys(),
     ...runtimeSummaryByStrategy.keys(),
     ...parityByStrategy.keys()
   ]);
   const rows = [...strategyNames].sort((left, right) => left.localeCompare(right)).map((strategyName) => {
-    const liveSummary = liveSummaryByStrategy.get(strategyName);
     const runtimeSummary = runtimeSummaryByStrategy.get(strategyName);
     const parity = parityByStrategy.get(strategyName);
     return {
       strategyName,
       backtestEntries: parity?.backtest ?? 0,
-      backtestNetProfit: liveSummary?.netProfit ?? 0,
+      backtestNetProfit: backtestPnlByStrategy.get(strategyName) ?? 0,
       runtimeTrades: runtimeSummary?.trades ?? 0,
       runtimePnl: runtimeSummary?.totalPnl ?? 0,
       matched: parity?.matched ?? 0,
+      orderFailed: 0,
       runtimeOnly: parity?.runtimeOnly ?? 0,
       backtestOnly: parity?.backtestOnly ?? 0
     };
@@ -8501,8 +9152,10 @@ var saveAndPrintReplayRuntimeComparison = async ({
       import_chalk11.default.yellow(String(row.runtimeTrades)),
       rtPnlColor(`${row.runtimePnl.toFixed(2)}$`),
       import_chalk11.default.green(String(row.matched)),
+      import_chalk11.default.red(String(row.orderFailed)),
       import_chalk11.default.yellow(String(row.runtimeOnly)),
-      import_chalk11.default.magenta(String(row.backtestOnly))
+      import_chalk11.default.magenta(String(row.backtestOnly)),
+      import_chalk11.default.red(String(getReplayRuntimeUnmatchedCount(row)))
     ];
   });
   console.log("");
@@ -8529,18 +9182,20 @@ var saveAndPrintReplayRuntimeComparison = async ({
     syncedTradesCount: syncedRuntimeTrades.length,
     windowTradesCount: windowRuntimeTrades.length,
     runtimeEntriesCount: runtimeDedupe.entries.length,
-    backtestEntriesCount: backtestEntries.length,
+    backtestEntriesCount: comparableBacktestEntries.length,
     matchedCount: comparison.matched.length,
+    orderFailedCount: 0,
     runtimeOnlyCount: comparison.runtimeOnly.length,
     backtestOnlyCount: comparison.backtestOnly.length,
     rows,
-    details
+    details,
+    lineage: comparable.lineage
   };
 };
 
 // src/lib/replay/outputReport.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __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",
@@ -8575,6 +9230,7 @@ var buildPerTradeAnalysis = (runtimeComparison) => {
   if (!details) {
     return {
       matched: [],
+      orderFailed: [],
       runtimeOnly: [],
       backtestOnly: []
     };
@@ -8603,6 +9259,17 @@ var buildPerTradeAnalysis = (runtimeComparison) => {
         slippage: item.slippage
       }
     })),
+    orderFailed: details.orderFailed.map((item) => ({
+      status: "orderFailed",
+      strategy: entryStrategy(item.backtest),
+      symbol: item.backtest.symbol,
+      direction: item.backtest.direction,
+      runtime: item.runtime,
+      backtest: item.backtest,
+      reason: item.reason,
+      timestampDiffMs: item.timestampDiffMs,
+      entryPriceDeltaPct: item.priceDeltaPct
+    })),
     runtimeOnly: details.runtimeOnly.map((entry) => ({
       status: "runtimeOnly",
       strategy: entryStrategy(entry),
@@ -8686,6 +9353,26 @@ var renderRuntimeOnlyRows = (perTrade) => perTrade.length ? createMarkdownTable(
     ];
   })
 ) : "_No runtime-only trades._";
+var renderOrderFailedRows = (perTrade) => perTrade.length ? createMarkdownTable(
+  [
+    "Strategy",
+    "Symbol",
+    "Dir",
+    "BT time",
+    "RT time",
+    "Entry delta",
+    "Reason"
+  ],
+  perTrade.map((item) => [
+    item.strategy,
+    item.symbol,
+    item.direction,
+    formatMsk(item.backtest.timestamp),
+    formatMsk(item.runtime.timestamp),
+    formatPct(item.entryPriceDeltaPct),
+    item.reason
+  ])
+) : "_No failed runtime orders._";
 var renderBacktestOnlyRows = (perTrade) => perTrade.length ? createMarkdownTable(
   [
     "Strategy",
@@ -8723,8 +9410,10 @@ var renderStrategyRows = (runtimeComparison) => runtimeComparison?.rows.length ?
     "RT trades",
     "RT PnL",
     "Matched",
+    "Order failed",
     "RT only",
-    "BT only"
+    "BT only",
+    "Unmatched"
   ],
   runtimeComparison.rows.map((row) => [
     row.strategyName,
@@ -8733,10 +9422,69 @@ var renderStrategyRows = (runtimeComparison) => runtimeComparison?.rows.length ?
     row.runtimeTrades,
     formatMoney(row.runtimePnl),
     row.matched,
+    row.orderFailed,
     row.runtimeOnly,
-    row.backtestOnly
+    row.backtestOnly,
+    getReplayRuntimeUnmatchedCount(row)
   ])
 ) : "_No runtime comparison rows._";
+var renderLineageRows = (runtimeComparison) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record of runtimeComparison?.lineage.replay ?? []) {
+    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()
+    };
+    existing.scopes += 1;
+    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);
+    grouped.set(record.strategy, existing);
+  }
+  const formatSet = (values) => {
+    const sorted = [...values].sort();
+    return sorted.length <= 3 ? sorted.join(", ") : `${sorted.slice(0, 3).join(", ")} \u2026 (+${sorted.length - 3})`;
+  };
+  return grouped.size ? createMarkdownTable(
+    [
+      "Strategy",
+      "Scopes",
+      "Git SHA",
+      "Dirty",
+      "Gate",
+      "Config variants",
+      "Context"
+    ],
+    [...grouped.values()].sort((left, right) => left.strategy.localeCompare(right.strategy)).map(
+      ({
+        strategy,
+        scopes,
+        gitShas,
+        dirty,
+        gates,
+        configs,
+        contexts
+      }) => [
+        strategy,
+        scopes,
+        formatSet(gitShas),
+        formatSet(dirty),
+        formatSet(gates),
+        `${configs.size}: ${formatSet(configs)}`,
+        formatSet(contexts)
+      ]
+    )
+  ) : "_No replay lineage records._";
+};
 var writeReplayOutputReport = async ({
   projectRoot,
   timestamp,
@@ -8751,8 +9499,8 @@ var writeReplayOutputReport = async ({
   strategySnapshot,
   runtimeComparison
 }) => {
-  const outputDir = import_node_path.default.resolve(projectRoot, "data/replay/output");
-  await import_promises.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",
@@ -8778,15 +9526,17 @@ var writeReplayOutputReport = async ({
       cycleCount: replayResult.cycleCount,
       abortedCycles: replayResult.abortedCycles,
       matched: runtimeComparison?.matchedCount ?? 0,
+      orderFailed: runtimeComparison?.orderFailedCount ?? 0,
       runtimeOnly: runtimeComparison?.runtimeOnlyCount ?? 0,
       backtestOnly: runtimeComparison?.backtestOnlyCount ?? 0
     },
     resultsByStrategies: strategySnapshot.summaries,
+    replayLineage: replayResult.runtimeLineages,
     runtimeComparison,
     perTradeAnalysis
   };
-  const markdownPath = import_node_path.default.join(outputDir, `${timestamp}-replay-report.md`);
-  const jsonPath = import_node_path.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",
     "",
@@ -8806,13 +9556,26 @@ var writeReplayOutputReport = async ({
         ["Window", `${formatMsk(window2.start)} - ${formatMsk(window2.end)} MSK`],
         ["Runtime compare mode", runtimeComparison?.mode ?? "none"],
         ["Matched", runtimeComparison?.matchedCount ?? 0],
+        ["Order failed", runtimeComparison?.orderFailedCount ?? 0],
         ["Runtime-only", runtimeComparison?.runtimeOnlyCount ?? 0],
         ["Backtest-only", runtimeComparison?.backtestOnlyCount ?? 0],
+        [
+          "Comparable lineage scopes",
+          runtimeComparison ? `${runtimeComparison.lineage.comparableScopes}/${runtimeComparison.lineage.replayScopes}` : "0/0"
+        ],
+        [
+          "Lineage exclusions",
+          runtimeComparison ? `runtime=${runtimeComparison.lineage.excludedRuntimeTrades}, exchange=${runtimeComparison.lineage.excludedExchangeEntries}, backtest=${runtimeComparison.lineage.excludedBacktestEntries}` : ""
+        ],
         ["Command", `\`${process.argv.join(" ")}\``],
         ["JSON report", jsonPath]
       ]
     ),
     "",
+    "## Replay Lineage",
+    "",
+    renderLineageRows(runtimeComparison),
+    "",
     "## Strategy Comparison",
     "",
     renderStrategyRows(runtimeComparison),
@@ -8821,6 +9584,10 @@ var writeReplayOutputReport = async ({
     "",
     renderMatchedRows(perTradeAnalysis.matched),
     "",
+    "## Failed Runtime Orders",
+    "",
+    renderOrderFailedRows(perTradeAnalysis.orderFailed),
+    "",
     "## Runtime-Only Trades",
     "",
     renderRuntimeOnlyRows(perTradeAnalysis.runtimeOnly),
@@ -8835,8 +9602,8 @@ var writeReplayOutputReport = async ({
     ""
   ];
   await Promise.all([
-    import_promises.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-    import_promises.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 {
@@ -8875,7 +9642,8 @@ var finishReplay = async ({
   const replayRuntimeComparison = await saveAndPrintReplayRuntimeComparison({
     liveStrategySummaries: replayStrategySnapshot.summaries,
     backtestEntries: replayStrategySnapshot.backtestEntries,
-    replaySignals: replayResult.signals
+    replaySignals: replayResult.signals,
+    replayLineages: replayResult.runtimeLineages
   });
   const finishedAt = /* @__PURE__ */ new Date();
   const durationSeconds = Number(
@@ -8891,7 +9659,7 @@ var finishReplay = async ({
       replayResult.orderLog[replayResult.orderLog.length - 1]?.timestamp ?? finishedAt.getTime()
     )}`
   }) : null;
-  const replayKey = import_redis5.redisKeys.backtestResults(
+  const replayKey = import_redis6.redisKeys.backtestResults(
     replayUserName,
     REPLAY_RESULTS_CONFIG,
     timestamp
@@ -8912,7 +9680,7 @@ var finishReplay = async ({
   });
   console.log(import_chalk12.default.green(`Replay report: ${outputReport.markdownPath}`));
   console.log(import_chalk12.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
-  await (0, import_redis5.setData)(
+  await (0, import_redis6.setData)(
     replayKey,
     {
       config: REPLAY_RESULTS_CONFIG,
@@ -8933,6 +9701,7 @@ var finishReplay = async ({
       cycleCount: replayResult.cycleCount,
       abortedCycles: replayResult.abortedCycles,
       signalsCount: replayResult.signals.length,
+      replayLineage: replayResult.runtimeLineages,
       strategyCharts: replayChartSnapshot,
       outputReport
     },
@@ -8943,8 +9712,8 @@ var finishReplay = async ({
   if (replayChartSnapshot) {
     await Promise.all(
       replayChartSnapshot.strategies.map(
-        (card) => (0, import_redis5.setData)(
-          import_redis5.redisKeys.strategyChartCard(replayUserName, "replay", card.cardId),
+        (card) => (0, import_redis6.setData)(
+          import_redis6.redisKeys.strategyChartCard(replayUserName, "replay", card.cardId),
           card,
           {
             expire: import_constants6.TTL_1M
@@ -8969,7 +9738,8 @@ var replayBacktest = async () => {
     endTime: replayFlags.endTime,
     cacheOnly: replayFlags.cacheOnly,
     interval: replayInterval,
-    projectRoot: replayProjectRoot
+    projectRoot: replayProjectRoot,
+    closedIntervalMs: (0, import_data2.intervalToMs)(replayInterval)
   });
   if (!preparedRun || isReplayUpdateOnlyRun) {
     return;