@tradejs/cli 3.1.19 → 3.1.20-beta.236

package/dist/scripts/replay.js

@@ -35,7 +35,7 @@ __export(replay_exports, {
 module.exports = __toCommonJS(replay_exports);
 
 // src/scripts/replayRunner.ts
-var import_chalk12 = __toESM(require("chalk"));
+var import_chalk13 = __toESM(require("chalk"));
 var import_constants6 = require("@tradejs/core/constants");
 var import_data2 = require("@tradejs/core/data");
 var import_time7 = require("@tradejs/core/time");
@@ -4948,7 +4948,6 @@ var compactReplaySignal = (signal) => {
 // src/lib/replay/historicalSignalsReplay.ts
 var import_chalk9 = __toESM(require("chalk"));
 var import_progress4 = __toESM(require("progress"));
-var import_backtest = require("@tradejs/core/backtest");
 var import_strategies3 = require("@tradejs/core/strategies");
 var import_time3 = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
@@ -5361,25 +5360,6 @@ var createPortfolioReplayConnector = (connector) => {
   };
 };
 
-// src/lib/marketData/windows.ts
-var import_indicators2 = require("@tradejs/core/indicators");
-var splitCandlesForReplayWindow = (candles, start, preloadStart) => {
-  const prevData = [];
-  const replayData = [];
-  for (const candle of candles) {
-    if (candle.timestamp < preloadStart) {
-      continue;
-    }
-    if (candle.timestamp < start) {
-      prevData.push(candle);
-      continue;
-    }
-    replayData.push(candle);
-  }
-  return { prevData, replayData };
-};
-var alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
-
 // src/lib/signals/hooks.ts
 var normalizeHookList = (value) => {
   if (Array.isArray(value)) {
@@ -5406,70 +5386,26 @@ var invokeAfterSignalsHooks = async (hooks, params) => {
   }
 };
 
-// src/lib/replay/historicalSignalsReplay.ts
-var loadRuntimeStrategies = async (runtimeStrategies) => {
-  const strategies = await Promise.all(
-    runtimeStrategies.map(async (runtimeStrategy) => {
-      const {
-        strategyName,
-        strategyRevision,
-        deploymentCompositionId,
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        selection
-      } = runtimeStrategy;
-      const strategyCreator = await (0, import_strategies4.getStrategyCreator)(
-        strategyName,
-        replayProjectRoot
-      );
-      if (!strategyCreator) {
-        throw new Error(`Unknown strategy: ${strategyName}`);
-      }
-      const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
-        strategyName,
-        projectRoot: replayProjectRoot
-      });
-      if (installed.strategyPackage !== strategyPackage || installed.strategyPackageVersion !== strategyPackageVersion || JSON.stringify(installed.strategyDependencyVersions) !== JSON.stringify(strategyDependencyVersions) || installed.runtimePackageVersion !== runtimePackageVersion) {
-        throw new Error(
-          `Runtime evidence package mismatch for ${strategyName}: expected=${strategyPackage}@${strategyPackageVersion}/@tradejs/node@${runtimePackageVersion}, installed=${installed.strategyPackage ?? "missing"}@${installed.strategyPackageVersion ?? "missing"}/@tradejs/node@${installed.runtimePackageVersion ?? "missing"}`
-        );
-      }
-      const strategyResults = await (0, import_redis3.getData)(
-        import_redis3.redisKeys.strategyResults(replayUserName, strategyName),
-        {}
-      );
-      return {
-        strategyName,
-        strategyRevision,
-        deploymentCompositionId,
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyCreator,
-        strategyConfig,
-        strategyResults,
-        ...selection ? { selection } : {}
-      };
-    })
-  );
-  return strategies;
-};
-var loadReferenceConnector = async (connectorName) => {
-  const connectorFactory = await (0, import_connectors6.getConnectorCreatorByName)(
-    connectorName,
-    replayProjectRoot
-  );
-  if (!connectorFactory) {
-    throw new Error(`Connector "${connectorName}" is not registered`);
+// src/lib/marketData/windows.ts
+var import_indicators2 = require("@tradejs/core/indicators");
+var splitCandlesForReplayWindow = (candles, start, preloadStart) => {
+  const prevData = [];
+  const replayData = [];
+  for (const candle of candles) {
+    if (candle.timestamp < preloadStart) {
+      continue;
+    }
+    if (candle.timestamp < start) {
+      prevData.push(candle);
+      continue;
+    }
+    replayData.push(candle);
   }
-  return await connectorFactory({
-    userName: replayUserName
-  });
+  return { prevData, replayData };
 };
+var alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
+
+// src/lib/replay/historicalSignalsReplayPreparation.ts
 var buildPreparedData = ({
   data,
   btcData,
@@ -5518,25 +5454,6 @@ var buildPreparedData = ({
     btcCoinbasePrevData
   };
 };
-var buildAfterSignalsContext = ({
-  connector,
-  connectorName,
-  tickers,
-  runtimeStrategies,
-  interval
-}) => ({
-  connector,
-  connectorName,
-  userName: replayUserName,
-  interval,
-  tickers: [...tickers],
-  runtimeStrategies: runtimeStrategies.map(
-    ({ strategyName, strategyConfig }) => ({
-      strategyName,
-      strategyConfig
-    })
-  )
-});
 var strategyIncludesSymbol = (strategy, symbol) => {
   const tickers = strategy.selection?.tickers;
   if (!tickers) return true;
@@ -5546,73 +5463,28 @@ var strategyIncludesSymbol = (strategy, symbol) => {
   );
 };
 var buildSymbolSharedReplayKey = ({
+  userName,
   connectorName,
   interval,
   symbol,
   start,
   end
-}) => ["replay", replayUserName, connectorName, symbol, interval, start, end].join(
-  ":"
-);
-var runHistoricalSignalsReplay = async ({
-  preparedRun,
-  interval,
-  runtimeStrategies
-}) => {
-  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);
-  const replayConnector = createPortfolioReplayConnector(
-    preparedRun.marketConnector
-  );
-  const connectorName = String(
-    preparedRun.marketConnector?.name || import_connectors6.DEFAULT_CONNECTOR_NAME
-  ).trim() || import_connectors6.DEFAULT_CONNECTOR_NAME;
-  const binanceConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Binance") : preparedRun.marketConnector;
-  const coinbaseConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Coinbase") : preparedRun.marketConnector;
-  const [btcBinanceData, btcCoinbaseData] = await Promise.all([
-    binanceConnector.kline({
-      symbol: "BTCUSDT",
-      start: preparedRun.preloadStart,
-      end: preparedRun.window.end,
-      cacheOnly: true,
-      interval
-    }),
-    coinbaseConnector.kline({
-      symbol: "BTCUSDT",
-      start: preparedRun.preloadStart,
-      end: preparedRun.window.end,
-      cacheOnly: true,
-      interval
-    })
-  ]);
-  const btcMarketData = await preparedRun.marketConnector.kline({
-    symbol: "BTCUSDT",
-    start: preparedRun.preloadStart,
-    end: preparedRun.window.end,
-    cacheOnly: true,
-    interval
-  });
-  const ethMarketData = await preparedRun.marketConnector.kline({
-    symbol: "ETHUSDT",
-    start: preparedRun.preloadStart,
-    end: preparedRun.window.end,
-    cacheOnly: true,
-    interval
-  });
+}) => ["replay", userName, connectorName, symbol, interval, start, end].join(":");
+var prepareHistoricalReplay = async (context, adapters) => {
+  const {
+    userName,
+    projectRoot,
+    preparedRun,
+    interval,
+    connectorName,
+    replayConnector,
+    strategies,
+    references
+  } = context;
   const cycleSymbolsByTimestamp = /* @__PURE__ */ new Map();
   const sharedReplayKeyPrefixes = [];
+  const runtimeLineages = [];
   let skippedSymbols = 0;
-  const prepareBar = new import_progress4.default(
-    "prepare :current/:total [:bar][:percent] skipped=:skipped :etas(s) :symbol",
-    {
-      total: preparedRun.tickers.length,
-      width: 30
-    }
-  );
   for (const symbol of preparedRun.tickers) {
     const data = await preparedRun.marketConnector.kline({
       symbol,
@@ -5623,22 +5495,23 @@ var runHistoricalSignalsReplay = async ({
     });
     const preparedData = buildPreparedData({
       data,
-      btcData: btcMarketData,
-      ethData: ethMarketData,
-      btcBinanceData,
-      btcCoinbaseData,
+      btcData: references.btcMarketData,
+      ethData: references.ethMarketData,
+      btcBinanceData: references.btcBinanceData,
+      btcCoinbaseData: references.btcCoinbaseData,
       start: preparedRun.window.start,
       preloadStart: preparedRun.preloadStart
     });
     if (!preparedData.replayData.length || !preparedData.btcReplayData.length) {
       skippedSymbols += 1;
-      prepareBar.tick(1, {
-        skipped: import_chalk9.default.yellow(skippedSymbols),
-        symbol: import_chalk9.default.gray(symbol)
+      adapters.progress.tick({
+        skipped: adapters.display.skipped(skippedSymbols),
+        symbol: adapters.display.symbol(symbol)
       });
       continue;
     }
     const sharedIndicatorsReplayKey = buildSymbolSharedReplayKey({
+      userName,
       connectorName,
       interval,
       symbol,
@@ -5647,66 +5520,61 @@ var runHistoricalSignalsReplay = async ({
     });
     sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
     const strategiesForSymbol = await Promise.all(
-      loadedStrategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(
-        async ({
-          strategyName,
-          strategyRevision,
-          deploymentCompositionId,
-          strategyPackageVersion,
-          strategyDependencyVersions,
-          runtimePackageVersion,
-          strategyCreator,
-          strategyConfig,
-          strategyResults
-        }) => {
-          const runtimeLineage = await buildRuntimeLineage({
-            strategyRevision,
-            deploymentCompositionId,
-            strategyPackageVersion,
-            strategyDependencyVersions,
-            runtimePackageVersion,
-            config: {
-              configId: strategyRevision,
-              strategyConfig,
-              symbolResultConfig: strategyResults?.[symbol]?.config ?? null
-            }
-          });
-          runtimeLineages.push({
-            strategy: strategyName,
-            symbol,
-            ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
-            ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
-            lineage: runtimeLineage
-          });
-          return {
-            strategyName,
-            strategyConfig,
+      strategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(async (strategy) => {
+        const runtimeLineage = await adapters.buildLineage({
+          projectRoot,
+          strategyName: strategy.strategyName,
+          strategyRevision: strategy.strategyRevision,
+          deploymentCompositionId: strategy.deploymentCompositionId,
+          strategyPackageVersion: strategy.strategyPackageVersion,
+          strategyDependencyVersions: strategy.strategyDependencyVersions,
+          runtimePackageVersion: strategy.runtimePackageVersion,
+          config: {
+            configId: strategy.strategyRevision,
+            strategyConfig: strategy.strategyConfig,
+            symbolResultConfig: strategy.strategyResults?.[symbol]?.config ?? null
+          },
+          runContext: {
+            connectorName: connectorName.toLowerCase(),
+            interval: String(interval),
+            universe: preparedRun.universe ?? null
+          }
+        });
+        runtimeLineages.push({
+          strategy: strategy.strategyName,
+          symbol,
+          ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
+          ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
+          lineage: runtimeLineage
+        });
+        return {
+          strategyName: strategy.strategyName,
+          strategyConfig: strategy.strategyConfig,
+          runtimeLineage,
+          run: await strategy.strategyCreator({
+            userName,
+            connectorName,
+            runtimeConfigId: strategy.strategyRevision,
+            strategyRevision: strategy.strategyRevision,
             runtimeLineage,
-            run: await strategyCreator({
-              userName: replayUserName,
-              connectorName,
-              runtimeConfigId: strategyRevision,
-              strategyRevision,
-              runtimeLineage,
-              universe: preparedRun.universe,
-              accountId: preparedRun.accountId,
-              deploymentId: preparedRun.deploymentId,
-              config: buildReplayStrategyConfig({
-                strategyConfig,
-                interval
-              }),
-              symbol,
-              data: preparedData.prevData,
-              btcData: preparedData.btcPrevData,
-              ethData: preparedData.ethPrevData,
-              btcBinanceData: preparedData.btcBinancePrevData,
-              btcCoinbaseData: preparedData.btcCoinbasePrevData,
-              connector: replayConnector,
-              sharedIndicatorsReplayKey
-            })
-          };
-        }
-      )
+            universe: preparedRun.universe,
+            accountId: preparedRun.accountId,
+            deploymentId: preparedRun.deploymentId,
+            config: buildReplayStrategyConfig({
+              strategyConfig: strategy.strategyConfig,
+              interval
+            }),
+            symbol,
+            data: preparedData.prevData,
+            btcData: preparedData.btcPrevData,
+            ethData: preparedData.ethPrevData,
+            btcBinanceData: preparedData.btcBinancePrevData,
+            btcCoinbaseData: preparedData.btcCoinbasePrevData,
+            connector: replayConnector,
+            sharedIndicatorsReplayKey
+          })
+        };
+      })
     );
     const symbolRuntime = {
       symbol,
@@ -5716,9 +5584,9 @@ var runHistoricalSignalsReplay = async ({
       currentIndex: 0,
       strategies: strategiesForSymbol
     };
-    prepareBar.tick(1, {
-      skipped: import_chalk9.default.yellow(skippedSymbols),
-      symbol: import_chalk9.default.gray(symbol)
+    adapters.progress.tick({
+      skipped: adapters.display.skipped(skippedSymbols),
+      symbol: adapters.display.symbol(symbol)
     });
     for (const candle of preparedData.replayData) {
       const bucket = cycleSymbolsByTimestamp.get(candle.timestamp) ?? [];
@@ -5726,60 +5594,66 @@ var runHistoricalSignalsReplay = async ({
       cycleSymbolsByTimestamp.set(candle.timestamp, bucket);
     }
   }
-  const orderedTimestamps = [...cycleSymbolsByTimestamp.keys()].sort(
-    (left, right) => left - right
-  );
-  const afterSignalsContextBase = buildAfterSignalsContext({
-    connector: replayConnector,
-    connectorName: preparedRun.connectorName,
-    tickers: preparedRun.tickers,
-    runtimeStrategies: loadedStrategies,
-    interval
-  });
-  let abortedCycles = 0;
-  const cycleBar = new import_progress4.default(
-    "cycles  :current/:total [:bar][:percent] sig=:signals abort=:aborted :etas(s) :ts",
-    {
-      total: orderedTimestamps.length,
-      width: 30
+  return {
+    cycleSymbolsByTimestamp,
+    orderedTimestamps: [...cycleSymbolsByTimestamp.keys()].sort(
+      (left, right) => left - right
+    ),
+    sharedReplayKeyPrefixes,
+    runtimeLineages
+  };
+};
+
+// src/lib/replay/historicalSignalsReplayExecution.ts
+var advanceCycleMarket = async (plan, connector, timestamp) => {
+  const cycleSymbols = plan.cycleSymbolsByTimestamp.get(timestamp) ?? [];
+  for (const symbolRuntime of cycleSymbols) {
+    const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
+    if (candle?.timestamp === timestamp) {
+      await connector.advanceMarket({
+        symbol: symbolRuntime.symbol,
+        candle
+      });
     }
-  );
+  }
+  return cycleSymbols;
+};
+var advanceAbortedCycle = (cycleSymbols, timestamp) => {
+  for (const symbolRuntime of cycleSymbols ?? []) {
+    const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
+    if (candle?.timestamp === timestamp) {
+      symbolRuntime.currentIndex += 1;
+    }
+  }
+};
+var executeHistoricalReplay = async (context, adapters) => {
+  const signals = [];
+  let abortedCycles = 0;
   try {
-    for (const timestamp of orderedTimestamps) {
-      const cycleStartedAt = Date.now();
-      const cycleSymbols = cycleSymbolsByTimestamp.get(timestamp) ?? [];
-      for (const symbolRuntime of cycleSymbols) {
-        const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
-        if (!candle || candle.timestamp !== timestamp) {
-          continue;
-        }
-        await replayConnector.advanceMarket({
-          symbol: symbolRuntime.symbol,
-          candle
-        });
-      }
-      const beforeSignalsResult = await invokeBeforeSignalsHooks(
-        projectHooks,
-        afterSignalsContextBase
+    for (const timestamp of context.plan.orderedTimestamps) {
+      const cycleStartedAt = adapters.clock.now();
+      const cycleSymbols = await advanceCycleMarket(
+        context.plan,
+        context.connector,
+        timestamp
+      );
+      const beforeSignalsResult = await adapters.invokeBeforeSignals(
+        context.hooks,
+        context.hookContext
       );
       if (beforeSignalsResult?.abort === true) {
         abortedCycles += 1;
-        await invokeAfterSignalsHooks(projectHooks, {
-          ...afterSignalsContextBase,
+        await adapters.invokeAfterSignals(context.hooks, {
+          ...context.hookContext,
           signals: [],
           status: "completed",
-          durationMs: Date.now() - cycleStartedAt
+          durationMs: adapters.clock.now() - cycleStartedAt
         });
-        for (const symbolRuntime of cycleSymbols) {
-          const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
-          if (candle?.timestamp === timestamp) {
-            symbolRuntime.currentIndex += 1;
-          }
-        }
-        cycleBar.tick(1, {
-          signals: import_chalk9.default.cyan(signals.length),
-          aborted: import_chalk9.default.yellow(abortedCycles),
-          ts: import_chalk9.default.gray((0, import_time3.formatUnix)(timestamp))
+        advanceAbortedCycle(cycleSymbols, timestamp);
+        adapters.progress.tick({
+          signals: adapters.display.signals(signals.length),
+          aborted: adapters.display.aborted(abortedCycles),
+          ts: adapters.display.timestamp(timestamp)
         });
         continue;
       }
@@ -5799,73 +5673,286 @@ var runHistoricalSignalsReplay = async ({
           );
           if (result && typeof result !== "string") {
             result.runtimeLineage = strategyRuntime.runtimeLineage;
-            await (0, import_strategies4.enrichSignalWithBinanceMarketContext)({
-              signal: result,
-              env: "PARITY"
-            });
+            await adapters.enrichSignal(result);
             cycleSignals.push(result);
             signals.push(result);
           }
         }
         symbolRuntime.currentIndex += 1;
       }
-      await invokeAfterSignalsHooks(projectHooks, {
-        ...afterSignalsContextBase,
+      await adapters.invokeAfterSignals(context.hooks, {
+        ...context.hookContext,
         signals: cycleSignals,
         status: "completed",
-        durationMs: Date.now() - cycleStartedAt
+        durationMs: adapters.clock.now() - cycleStartedAt
       });
-      cycleBar.tick(1, {
-        signals: import_chalk9.default.cyan(signals.length),
-        aborted: import_chalk9.default.yellow(abortedCycles),
-        ts: import_chalk9.default.gray((0, import_time3.formatUnix)(timestamp))
+      adapters.progress.tick({
+        signals: adapters.display.signals(signals.length),
+        aborted: adapters.display.aborted(abortedCycles),
+        ts: adapters.display.timestamp(timestamp)
       });
     }
   } finally {
-    for (const keyPrefix of sharedReplayKeyPrefixes) {
-      (0, import_strategies3.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-      (0, import_strategies3.releaseStrategyReplayCache)(keyPrefix);
+    for (const keyPrefix of context.plan.sharedReplayKeyPrefixes) {
+      adapters.releaseIndicatorsCache(keyPrefix);
+      adapters.releaseReplayCache(keyPrefix);
     }
   }
-  const artifacts = replayConnector.getReplayArtifacts();
-  const strategies = loadedStrategies.map(
-    ({ strategyName, strategyConfig }) => {
-      const orderLog = artifacts.orderLogByStrategy.get(strategyName) ?? [];
-      const positionLog = artifacts.positionLogByStrategy.get(strategyName) ?? [];
-      return {
-        strategyName,
-        strategyConfig,
-        orderLog,
-        positionLog,
-        stat: positionLog.length ? (0, import_backtest.calculateStatsFull)(positionLog) : {
-          orders: 0,
-          wins: 0,
-          losses: 0,
-          netProfit: 0,
-          amount: 0
-        }
-      };
-    }
-  );
-  import_logger.logger.info(
-    import_chalk9.default.gray(
-      `signals replay historical cycles: ${orderedTimestamps.length} (aborted=${abortedCycles}) done in ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`
-    )
-  );
-  return {
-    strategies,
-    signals,
-    orderLog: artifacts.orderLog,
-    positionLog: artifacts.positionLog,
-    cycleCount: orderedTimestamps.length,
-    abortedCycles,
-    runtimeLineages
-  };
+  return { signals, abortedCycles };
 };
 
-// src/lib/replay/chartSnapshot.ts
-var formatPercent = (value) => typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(1)}%` : "n/a";
-var formatSigned = (value) => typeof value === "number" && Number.isFinite(value) ? `${value >= 0 ? "+" : ""}${value.toFixed(2)}` : "n/a";
+// src/lib/replay/historicalSignalsReplayResults.ts
+var import_backtest = require("@tradejs/core/backtest");
+var emptyStat = () => ({
+  orders: 0,
+  wins: 0,
+  losses: 0,
+  netProfit: 0,
+  amount: 0
+});
+var collectHistoricalReplayResult = (context) => ({
+  strategies: context.strategies.map(({ strategyName, strategyConfig }) => {
+    const orderLog = context.artifacts.orderLogByStrategy.get(strategyName) ?? [];
+    const positionLog = context.artifacts.positionLogByStrategy.get(strategyName) ?? [];
+    return {
+      strategyName,
+      strategyConfig,
+      orderLog,
+      positionLog,
+      stat: positionLog.length ? (0, import_backtest.calculateStatsFull)(positionLog) : emptyStat()
+    };
+  }),
+  signals: context.signals,
+  orderLog: context.artifacts.orderLog,
+  positionLog: context.artifacts.positionLog,
+  cycleCount: context.cycleCount,
+  abortedCycles: context.abortedCycles,
+  runtimeLineages: context.runtimeLineages
+});
+
+// src/lib/replay/historicalSignalsReplay.ts
+var loadRuntimeStrategies = async (runtimeStrategies) => {
+  const strategies = await Promise.all(
+    runtimeStrategies.map(async (runtimeStrategy) => {
+      const {
+        strategyName,
+        strategyRevision,
+        deploymentCompositionId,
+        strategyPackage,
+        strategyPackageVersion,
+        strategyDependencyVersions,
+        runtimePackageVersion,
+        strategyConfig,
+        selection
+      } = runtimeStrategy;
+      const strategyCreator = await (0, import_strategies4.getStrategyCreator)(
+        strategyName,
+        replayProjectRoot
+      );
+      if (!strategyCreator) {
+        throw new Error(`Unknown strategy: ${strategyName}`);
+      }
+      const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
+        strategyName,
+        projectRoot: replayProjectRoot
+      });
+      if (installed.strategyPackage !== strategyPackage || installed.strategyPackageVersion !== strategyPackageVersion || JSON.stringify(installed.strategyDependencyVersions) !== JSON.stringify(strategyDependencyVersions) || installed.runtimePackageVersion !== runtimePackageVersion) {
+        throw new Error(
+          `Runtime evidence package mismatch for ${strategyName}: expected=${strategyPackage}@${strategyPackageVersion}/@tradejs/node@${runtimePackageVersion}, installed=${installed.strategyPackage ?? "missing"}@${installed.strategyPackageVersion ?? "missing"}/@tradejs/node@${installed.runtimePackageVersion ?? "missing"}`
+        );
+      }
+      const strategyResults = await (0, import_redis3.getData)(
+        import_redis3.redisKeys.strategyResults(replayUserName, strategyName),
+        {}
+      );
+      return {
+        strategyName,
+        strategyRevision,
+        deploymentCompositionId,
+        strategyPackage,
+        strategyPackageVersion,
+        strategyDependencyVersions,
+        runtimePackageVersion,
+        strategyCreator,
+        strategyConfig,
+        strategyResults,
+        ...selection ? { selection } : {}
+      };
+    })
+  );
+  return strategies;
+};
+var loadReferenceConnector = async (connectorName) => {
+  const connectorFactory = await (0, import_connectors6.getConnectorCreatorByName)(
+    connectorName,
+    replayProjectRoot
+  );
+  if (!connectorFactory) {
+    throw new Error(`Connector "${connectorName}" is not registered`);
+  }
+  return await connectorFactory({
+    userName: replayUserName
+  });
+};
+var buildAfterSignalsContext = ({
+  connector,
+  connectorName,
+  tickers,
+  runtimeStrategies,
+  interval
+}) => ({
+  connector,
+  connectorName,
+  userName: replayUserName,
+  interval,
+  tickers: [...tickers],
+  runtimeStrategies: runtimeStrategies.map(
+    ({ strategyName, strategyConfig }) => ({
+      strategyName,
+      strategyConfig
+    })
+  )
+});
+var getConnectorName = (connector) => {
+  const name = "name" in connector ? connector.name : void 0;
+  return String(name || import_connectors6.DEFAULT_CONNECTOR_NAME).trim() || import_connectors6.DEFAULT_CONNECTOR_NAME;
+};
+var runHistoricalSignalsReplay = async ({
+  preparedRun,
+  interval,
+  runtimeStrategies
+}) => {
+  const startedAt = Date.now();
+  const projectConfig = await (0, import_cli4.loadTradejsConfig)(replayProjectRoot);
+  const projectHooks = projectConfig.hooks;
+  const loadedStrategies = await loadRuntimeStrategies(runtimeStrategies);
+  const replayConnector = createPortfolioReplayConnector(
+    preparedRun.marketConnector
+  );
+  const connectorName = getConnectorName(preparedRun.marketConnector);
+  const binanceConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Binance") : preparedRun.marketConnector;
+  const coinbaseConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Coinbase") : preparedRun.marketConnector;
+  const [btcBinanceData, btcCoinbaseData] = await Promise.all([
+    binanceConnector.kline({
+      symbol: "BTCUSDT",
+      start: preparedRun.preloadStart,
+      end: preparedRun.window.end,
+      cacheOnly: true,
+      interval
+    }),
+    coinbaseConnector.kline({
+      symbol: "BTCUSDT",
+      start: preparedRun.preloadStart,
+      end: preparedRun.window.end,
+      cacheOnly: true,
+      interval
+    })
+  ]);
+  const btcMarketData = await preparedRun.marketConnector.kline({
+    symbol: "BTCUSDT",
+    start: preparedRun.preloadStart,
+    end: preparedRun.window.end,
+    cacheOnly: true,
+    interval
+  });
+  const ethMarketData = await preparedRun.marketConnector.kline({
+    symbol: "ETHUSDT",
+    start: preparedRun.preloadStart,
+    end: preparedRun.window.end,
+    cacheOnly: true,
+    interval
+  });
+  const prepareBar = new import_progress4.default(
+    "prepare :current/:total [:bar][:percent] skipped=:skipped :etas(s) :symbol",
+    {
+      total: preparedRun.tickers.length,
+      width: 30
+    }
+  );
+  const plan = await prepareHistoricalReplay(
+    {
+      userName: replayUserName,
+      projectRoot: replayProjectRoot,
+      preparedRun,
+      interval,
+      connectorName,
+      replayConnector,
+      strategies: loadedStrategies,
+      references: {
+        btcMarketData,
+        ethMarketData,
+        btcBinanceData,
+        btcCoinbaseData
+      }
+    },
+    {
+      progress: {
+        tick: (tokens) => prepareBar.tick(1, tokens)
+      },
+      display: {
+        skipped: (value) => import_chalk9.default.yellow(value),
+        symbol: (value) => import_chalk9.default.gray(value)
+      },
+      buildLineage: buildRuntimeLineage
+    }
+  );
+  const hookContext = buildAfterSignalsContext({
+    connector: replayConnector,
+    connectorName: preparedRun.connectorName,
+    tickers: preparedRun.tickers,
+    runtimeStrategies: loadedStrategies,
+    interval
+  });
+  const cycleBar = new import_progress4.default(
+    "cycles  :current/:total [:bar][:percent] sig=:signals abort=:aborted :etas(s) :ts",
+    {
+      total: plan.orderedTimestamps.length,
+      width: 30
+    }
+  );
+  const execution = await executeHistoricalReplay(
+    {
+      plan,
+      connector: replayConnector,
+      hooks: projectHooks,
+      hookContext
+    },
+    {
+      clock: { now: Date.now },
+      progress: {
+        tick: (tokens) => cycleBar.tick(1, tokens)
+      },
+      display: {
+        signals: (value) => import_chalk9.default.cyan(value),
+        aborted: (value) => import_chalk9.default.yellow(value),
+        timestamp: (value) => import_chalk9.default.gray((0, import_time3.formatUnix)(value))
+      },
+      invokeBeforeSignals: invokeBeforeSignalsHooks,
+      invokeAfterSignals: invokeAfterSignalsHooks,
+      enrichSignal: (signal) => (0, import_strategies4.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" }),
+      releaseIndicatorsCache: import_strategies3.releaseStrategyIndicatorsReplayCache,
+      releaseReplayCache: import_strategies3.releaseStrategyReplayCache
+    }
+  );
+  const artifacts = replayConnector.getReplayArtifacts();
+  import_logger.logger.info(
+    import_chalk9.default.gray(
+      `signals replay historical cycles: ${plan.orderedTimestamps.length} (aborted=${execution.abortedCycles}) done in ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`
+    )
+  );
+  return collectHistoricalReplayResult({
+    strategies: loadedStrategies,
+    artifacts,
+    signals: execution.signals,
+    cycleCount: plan.orderedTimestamps.length,
+    abortedCycles: execution.abortedCycles,
+    runtimeLineages: plan.runtimeLineages
+  });
+};
+
+// src/lib/replay/chartSnapshot.ts
+var formatPercent = (value) => typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(1)}%` : "n/a";
+var formatSigned = (value) => typeof value === "number" && Number.isFinite(value) ? `${value >= 0 ? "+" : ""}${value.toFixed(2)}` : "n/a";
 var toSimpleOrderLog = (orderLog) => orderLog.map((entry) => [entry.timestamp, entry.amount]);
 var toReplayChartOrders = (orderLog) => orderLog.map((entry, index) => {
   const isOpenOrder = entry.type.startsWith("OPEN");
@@ -6267,8 +6354,7 @@ var saveAndPrintReplayResultsByStrategy = async ({
 };
 
 // src/lib/replay/runtimeComparison.ts
-var import_chalk11 = __toESM(require("chalk"));
-var import_time6 = require("@tradejs/core/time");
+var import_chalk12 = __toESM(require("chalk"));
 
 // src/lib/paritySummary.ts
 var summarizeRuntimeTradesByStrategy = (trades) => {
@@ -7452,31 +7538,7 @@ var buildReplayExchangeComparisonDetails = ({
   };
 };
 
-// src/lib/replay/runtimeComparison.ts
-var getReplayEntryTimestampCompareOffsetMs = () => {
-  const intervalMinutes = Number(replayInterval);
-  return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 60 * 1e3 : 15 * 60 * 1e3;
-};
-var buildReplaySignalEvaluations = (signals) => signals.map((signal) => ({
-  evaluationId: `${signal.strategy}:${signal.symbol}:${signal.timestamp}`,
-  userName: replayUserName,
-  strategy: signal.strategy,
-  symbol: signal.symbol,
-  interval: signal.interval,
-  timestamp: signal.timestamp,
-  evaluatedAt: signal.timestamp,
-  status: "signal",
-  reason: signal.orderSkipReason || signal.orderStatus || "SIGNAL",
-  signalId: signal.signalId,
-  direction: signal.direction,
-  accountId: signal.accountId,
-  deploymentId: signal.deploymentId,
-  runtimeLineage: signal.runtimeLineage,
-  orderStatus: signal.orderStatus,
-  orderSkipReason: signal.orderSkipReason,
-  ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
-  ...signal.ml ? { ml: signal.ml } : {}
-}));
+// src/lib/replay/runtimeComparisonCalculations.ts
 var lineageScopeKey = ({
   strategy,
   symbol,
@@ -7496,12 +7558,7 @@ var hasExpectedLineage = ({
 }) => runtimeLineagesComparable(
   lineage,
   expectedByScope.get(
-    lineageScopeKey({
-      strategy,
-      symbol,
-      deploymentId,
-      accountId
-    })
+    lineageScopeKey({ strategy, symbol, deploymentId, accountId })
   )
 );
 var filterReplayComparisonByLineage = ({
@@ -7623,13 +7680,7 @@ var filterReplayComparisonByLineage = ({
       reason: comparableScopeKeys.size > 0 ? null : expectedByScope.size === 0 ? "replay_produced_no_lineage_scopes" : "no_runtime_artifacts_with_matching_lineage",
       replay: [...expectedByScope.entries()].map(([scope, lineage]) => {
         const [deploymentId, accountId, strategy, symbol] = scope.split("::");
-        return {
-          deploymentId,
-          accountId,
-          strategy,
-          symbol,
-          lineage
-        };
+        return { deploymentId, accountId, strategy, symbol, lineage };
       }).sort(
         (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || runtimeLineageKey(left.lineage).localeCompare(
           runtimeLineageKey(right.lineage)
@@ -7638,29 +7689,174 @@ var filterReplayComparisonByLineage = ({
     }
   };
 };
-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) => {
-  let sum = 0;
-  let hasValue = false;
-  for (const value of values) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      continue;
-    }
-    sum += value;
-    hasValue = true;
+var buildPriceDeltaPct3 = (leftPrice, rightPrice) => {
+  if (leftPrice == null || rightPrice == null || !Number.isFinite(leftPrice) || !Number.isFinite(rightPrice) || leftPrice === 0) {
+    return null;
   }
-  return hasValue ? Number(sum.toFixed(12)) : null;
+  return Math.abs((rightPrice - leftPrice) / leftPrice * 100);
 };
-var firstFiniteNumber = (values) => {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
+var compareExchangeEntriesToBacktest = ({
+  exchangeEntries,
+  backtestEntries,
+  toleranceMs,
+  backtestTimestampOffsetMs = 0
+}) => {
+  const groupedExchange = /* @__PURE__ */ new Map();
+  const groupedBacktest = /* @__PURE__ */ new Map();
+  for (const entry of exchangeEntries) {
+    const key = `${entry.symbol}::${entry.direction}`;
+    const bucket = groupedExchange.get(key) ?? [];
+    bucket.push(entry);
+    groupedExchange.set(key, bucket);
   }
-  return null;
+  for (const entry of backtestEntries) {
+    const key = `${entry.symbol}::${entry.direction}`;
+    const bucket = groupedBacktest.get(key) ?? [];
+    bucket.push(entry);
+    groupedBacktest.set(key, bucket);
+  }
+  const matched = [];
+  const exchangeOnly = [];
+  const backtestOnly = [];
+  const matchedBacktestEntries = /* @__PURE__ */ new Set();
+  const groupKeys = /* @__PURE__ */ new Set([
+    ...groupedExchange.keys(),
+    ...groupedBacktest.keys()
+  ]);
+  for (const key of groupKeys) {
+    const exchangeGroup = [...groupedExchange.get(key) ?? []].sort(
+      (left, right) => left.entryTimestamp - right.entryTimestamp
+    );
+    const unmatchedBacktest = [...groupedBacktest.get(key) ?? []].sort((left, right) => left.timestamp - right.timestamp).map((entry) => ({ entry, used: false }));
+    for (const exchangeEntry of exchangeGroup) {
+      let bestIndex = -1;
+      let bestDiff = Number.POSITIVE_INFINITY;
+      for (let index = 0; index < unmatchedBacktest.length; index += 1) {
+        const candidate = unmatchedBacktest[index];
+        if (candidate.used) continue;
+        const diff = Math.abs(
+          getBacktestParityComparisonTimestamp(
+            candidate.entry,
+            backtestTimestampOffsetMs
+          ) - exchangeEntry.entryTimestamp
+        );
+        if (diff > toleranceMs || diff >= bestDiff) continue;
+        bestIndex = index;
+        bestDiff = diff;
+      }
+      if (bestIndex < 0) {
+        exchangeOnly.push(exchangeEntry);
+        continue;
+      }
+      unmatchedBacktest[bestIndex].used = true;
+      const backtestEntry = unmatchedBacktest[bestIndex].entry;
+      matchedBacktestEntries.add(backtestEntry);
+      matched.push({
+        exchange: exchangeEntry,
+        backtest: backtestEntry,
+        timestampDiffMs: bestDiff,
+        priceDeltaPct: buildPriceDeltaPct3(
+          exchangeEntry.entryPrice,
+          backtestEntry.price
+        )
+      });
+    }
+  }
+  for (const entry of backtestEntries) {
+    if (!matchedBacktestEntries.has(entry)) backtestOnly.push(entry);
+  }
+  matched.sort(
+    (left, right) => left.exchange.entryTimestamp - right.exchange.entryTimestamp || left.backtest.strategy.localeCompare(right.backtest.strategy)
+  );
+  exchangeOnly.sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
+  backtestOnly.sort((left, right) => left.timestamp - right.timestamp);
+  return { matched, exchangeOnly, 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 hasLineageLinkedRuntimeOutcome = ({
+  exchangeEntry,
+  strategyName,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  toleranceMs,
+  signalTimestampOffsetMs
+}) => findExchangeRuntimeOutcome({
+  exchangeEntry,
+  strategyName,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  toleranceMs,
+  signalTimestampOffsetMs
+}) != 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 firstString = (values) => values.find((value) => typeof value === "string" && value.trim());
 var summarizeBacktestPnlByStrategy = (entries) => {
   const totals = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -7669,6 +7865,231 @@ var summarizeBacktestPnlByStrategy = (entries) => {
   }
   return totals;
 };
+var buildExchangeComparisonRows = ({
+  liveStrategySummaries,
+  backtestEntries,
+  matched,
+  orderFailed,
+  exchangeOnly,
+  strategyNameByOrderLinkKey
+}) => {
+  const backtestPnlByStrategy = summarizeBacktestPnlByStrategy(backtestEntries);
+  const rowByStrategy = /* @__PURE__ */ new Map();
+  const ensureRow = (strategyName) => {
+    const existing = rowByStrategy.get(strategyName);
+    if (existing) return existing;
+    const next = {
+      strategyName,
+      backtestEntries: 0,
+      backtestNetProfit: backtestPnlByStrategy.get(strategyName) ?? 0,
+      runtimeTrades: 0,
+      runtimePnl: 0,
+      matched: 0,
+      orderFailed: 0,
+      runtimeOnly: 0,
+      backtestOnly: 0
+    };
+    rowByStrategy.set(strategyName, next);
+    return next;
+  };
+  for (const summary of liveStrategySummaries) ensureRow(summary.strategyName);
+  for (const entry of backtestEntries) {
+    ensureRow(entry.strategy).backtestEntries += 1;
+  }
+  for (const item of matched) {
+    const row = ensureRow(item.backtest.strategy);
+    row.runtimeTrades += 1;
+    row.matched += 1;
+    if (typeof item.exchange.closedPnl === "number" && Number.isFinite(item.exchange.closedPnl)) {
+      row.runtimePnl += item.exchange.closedPnl;
+    }
+  }
+  for (const item of orderFailed) {
+    const row = ensureRow(item.backtest.strategy);
+    row.runtimeTrades += 1;
+    row.orderFailed += 1;
+  }
+  const matchedBacktestEntries = /* @__PURE__ */ new Set([
+    ...matched.map(({ backtest }) => backtest),
+    ...orderFailed.map(({ backtest }) => backtest)
+  ]);
+  for (const entry of backtestEntries) {
+    if (!matchedBacktestEntries.has(entry)) {
+      ensureRow(entry.strategy).backtestOnly += 1;
+    }
+  }
+  for (const entry of exchangeOnly) {
+    const strategyName = resolveReplayStrategyNameFromExchangeEntry({
+      exchangeEntry: entry,
+      strategyNameByOrderLinkKey
+    }) ?? "[exchange-unmatched]";
+    const row = ensureRow(strategyName);
+    row.runtimeTrades += 1;
+    row.runtimeOnly += 1;
+    if (typeof entry.closedPnl === "number" && Number.isFinite(entry.closedPnl)) {
+      row.runtimePnl += entry.closedPnl;
+    }
+  }
+  return [...rowByStrategy.values()].map((row) => ({
+    ...row,
+    runtimePnl: Number(row.runtimePnl.toFixed(2))
+  })).sort((left, right) => left.strategyName.localeCompare(right.strategyName));
+};
+var buildRuntimeComparisonRows = ({
+  liveStrategySummaries,
+  runtimeSummaries,
+  parityRows,
+  backtestEntries
+}) => {
+  const runtimeSummaryByStrategy = new Map(
+    runtimeSummaries.map((summary) => [summary.strategyName, summary])
+  );
+  const parityByStrategy = new Map(parityRows);
+  const backtestPnlByStrategy = summarizeBacktestPnlByStrategy(backtestEntries);
+  const strategyNames = /* @__PURE__ */ new Set([
+    ...liveStrategySummaries.map(({ strategyName }) => strategyName),
+    ...runtimeSummaryByStrategy.keys(),
+    ...parityByStrategy.keys()
+  ]);
+  return [...strategyNames].sort((left, right) => left.localeCompare(right)).map((strategyName) => {
+    const runtimeSummary = runtimeSummaryByStrategy.get(strategyName);
+    const parity = parityByStrategy.get(strategyName);
+    return {
+      strategyName,
+      backtestEntries: parity?.backtest ?? 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
+    };
+  });
+};
+
+// src/lib/replay/runtimeComparisonReporting.ts
+var import_chalk11 = __toESM(require("chalk"));
+var import_time6 = require("@tradejs/core/time");
+var formatDrilldownSummary = (summary) => Object.entries(summary).filter(([, count]) => count > 0).map(([classification, count]) => `${classification}=${count}`).join(", ");
+var colorizeRows = (rows) => rows.map((row) => {
+  const btPnlColor = row.backtestNetProfit > 0 ? import_chalk11.default.green : row.backtestNetProfit < 0 ? import_chalk11.default.red : import_chalk11.default.gray;
+  const rtPnlColor = row.runtimePnl > 0 ? import_chalk11.default.green : row.runtimePnl < 0 ? import_chalk11.default.red : import_chalk11.default.gray;
+  return [
+    import_chalk11.default.blue(row.strategyName),
+    import_chalk11.default.cyan(String(row.backtestEntries)),
+    btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
+    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.red(String(getReplayRuntimeUnmatchedCount(row)))
+  ];
+});
+var buildReplayComparisonReport = (context) => {
+  const source = context.mode === "exchange" ? "EXCHANGE" : "RUNTIME";
+  const inference = context.mode === "exchange" ? ", inferredStrategy=orderLinkId | nearest backtest entry" : "";
+  const runtimeOnlyLabel = context.mode === "exchange" ? "exchangeOnly" : "runtimeOnly";
+  const runtimeOnlyDrilldownSummary = formatDrilldownSummary(
+    context.details?.mismatchDrilldown?.summary.runtimeOnly ?? {}
+  );
+  const backtestOnlyDrilldownSummary = formatDrilldownSummary(
+    context.details?.mismatchDrilldown?.summary.backtestOnly ?? {}
+  );
+  const lines = [
+    "",
+    `SIGNALS REPLAY VS ${source} BY STRATEGY (connector=${context.connectorName}${inference}, tolerance=${formatReplayRuntimeCompareTolerance()})`,
+    createTable(REPLAY_RUNTIME_COMPARISON_HEADERS, colorizeRows(context.rows))
+  ];
+  if (runtimeOnlyDrilldownSummary || backtestOnlyDrilldownSummary) {
+    lines.push(
+      import_chalk11.default.gray(
+        `Mismatch drilldown: ${runtimeOnlyLabel}=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
+      )
+    );
+  }
+  lines.push("");
+  return lines;
+};
+var buildNoExchangeEntriesReport = ({
+  connectorName,
+  window
+}) => [
+  "",
+  import_chalk11.default.yellow(
+    `SIGNALS REPLAY VS EXCHANGE: no lineage-linked exchange entry executions found for ${connectorName} in ${(0, import_time6.formatUnix)(
+      window.start
+    )} -> ${(0, import_time6.formatUnix)(window.end)}`
+  ),
+  ""
+];
+var buildNoRuntimeTradesReport = ({
+  connectorName,
+  window
+}) => [
+  "",
+  import_chalk11.default.yellow(
+    `SIGNALS REPLAY VS RUNTIME: no local runtime trades found for ${connectorName} in ${(0, import_time6.formatUnix)(
+      window.start
+    )} -> ${(0, import_time6.formatUnix)(window.end)} with matching lineage; checking lineage-linked exchange executions`
+  ),
+  ""
+];
+var writeReplayComparisonReport = (lines) => {
+  for (const line of lines) {
+    console.log(line);
+  }
+};
+
+// src/lib/replay/runtimeComparison.ts
+var getReplayEntryTimestampCompareOffsetMs = () => {
+  const intervalMinutes = Number(replayInterval);
+  return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 60 * 1e3 : 15 * 60 * 1e3;
+};
+var buildReplaySignalEvaluations = (signals) => signals.map((signal) => ({
+  evaluationId: `${signal.strategy}:${signal.symbol}:${signal.timestamp}`,
+  userName: replayUserName,
+  strategy: signal.strategy,
+  symbol: signal.symbol,
+  interval: signal.interval,
+  timestamp: signal.timestamp,
+  evaluatedAt: signal.timestamp,
+  status: "signal",
+  reason: signal.orderSkipReason || signal.orderStatus || "SIGNAL",
+  signalId: signal.signalId,
+  direction: signal.direction,
+  accountId: signal.accountId,
+  deploymentId: signal.deploymentId,
+  runtimeLineage: signal.runtimeLineage,
+  orderStatus: signal.orderStatus,
+  orderSkipReason: signal.orderSkipReason,
+  ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
+  ...signal.ml ? { ml: signal.ml } : {}
+}));
+var toFiniteNumberOrNull4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var sumOptionalNumbers = (values) => {
+  let sum = 0;
+  let hasValue = false;
+  for (const value of values) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      continue;
+    }
+    sum += value;
+    hasValue = true;
+  }
+  return hasValue ? Number(sum.toFixed(12)) : null;
+};
+var firstFiniteNumber = (values) => {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return null;
+};
+var firstString = (values) => values.find((value) => typeof value === "string" && value.trim());
 var getExchangeExecutionMergeKey = (entry) => {
   const orderId = firstString([entry.orderId, entry.orderLinkId]);
   return orderId ? `${entry.symbol}::${entry.direction}::${orderId}` : null;
@@ -7736,276 +8157,103 @@ var mergeExchangeEntryExecutions = (rows) => {
     );
   }
   return mergedRows.sort(
-    (left, right) => left.entryTimestamp - right.entryTimestamp
-  );
-};
-var loadExchangeEntryRows = async ({
-  connector,
-  startTime,
-  endTime
-}) => {
-  if (typeof connector.getEntryExecutions !== "function") {
-    console.log(
-      import_chalk11.default.yellow(
-        "runtime compare: connector does not support entry execution history"
-      )
-    );
-    return [];
-  }
-  const rows = [];
-  const chunks = splitExchangeHistoryTimeRange({ startTime, endTime });
-  for (const chunk of chunks) {
-    try {
-      const chunkRows = await connector.getEntryExecutions({
-        startTime: chunk.startTime,
-        endTime: chunk.endTime,
-        limit: 100
-      });
-      if (chunkRows.length >= 100) {
-        console.log(
-          import_chalk11.default.yellow(
-            "runtime compare: exchange entry executions returned 100 rows (connector cap); older entry trades in this chunk may be truncated"
-          )
-        );
-      }
-      rows.push(...chunkRows);
-    } catch (error) {
-      console.log(
-        import_chalk11.default.yellow(
-          `runtime compare: getEntryExecutions failed: ${formatRuntimeTradeSyncError(error)}`
-        )
-      );
-    }
-  }
-  return mergeExchangeEntryExecutions(rows);
-};
-var buildPriceDeltaPct3 = (leftPrice, rightPrice) => {
-  if (leftPrice == null || rightPrice == null || !Number.isFinite(leftPrice) || !Number.isFinite(rightPrice) || leftPrice === 0) {
-    return null;
-  }
-  return Math.abs((rightPrice - leftPrice) / leftPrice * 100);
-};
-var loadExchangeEntriesForComparison = async ({
-  connector,
-  startTime,
-  endTime
-}) => {
-  const entryRows = await loadExchangeEntryRows({
-    connector,
-    startTime,
-    endTime
-  });
-  const closedPnlRows = await loadClosedPnlRows({
-    connector,
-    startTime,
-    endTime,
-    callbacks: {
-      onUnsupported: () => {
-        console.log(
-          import_chalk11.default.yellow(
-            "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
-          )
-        );
-      },
-      onCapped: () => {
-        console.log(
-          import_chalk11.default.yellow(
-            "runtime compare: exchange closed pnl returned 100 rows (connector cap); older closed trades in the window may be truncated"
-          )
-        );
-      },
-      onError: (error) => {
-        console.log(
-          import_chalk11.default.yellow(
-            `runtime compare: getClosedPnl failed: ${formatRuntimeTradeSyncError(error)}`
-          )
-        );
-      }
-    }
-  });
-  const closedPnlByOrderId = new Map(
-    closedPnlRows.filter((row) => typeof row.orderId === "string" && row.orderId.trim()).map((row) => [row.orderId, row])
-  );
-  return entryRows.map((entry) => {
-    const closedPnl = typeof entry.orderId === "string" ? closedPnlByOrderId.get(entry.orderId) : null;
-    return {
-      ...entry,
-      exitPrice: closedPnl?.exitPrice ?? entry.exitPrice ?? null,
-      exitTimestamp: closedPnl?.closedAt ?? entry.exitTimestamp ?? null,
-      closedPnl: closedPnl?.closedPnl ?? entry.closedPnl ?? null,
-      openFee: closedPnl?.openFee ?? entry.openFee ?? null,
-      closeFee: closedPnl?.closeFee ?? entry.closeFee ?? null,
-      fundingFee: closedPnl?.fundingFee ?? entry.fundingFee ?? null,
-      totalFee: closedPnl?.totalFee ?? entry.totalFee ?? null
-    };
-  });
-};
-var compareExchangeEntriesToBacktest = ({
-  exchangeEntries,
-  backtestEntries,
-  toleranceMs,
-  backtestTimestampOffsetMs = 0
-}) => {
-  const groupedExchange = /* @__PURE__ */ new Map();
-  const groupedBacktest = /* @__PURE__ */ new Map();
-  for (const entry of exchangeEntries) {
-    const key = `${entry.symbol}::${entry.direction}`;
-    const bucket = groupedExchange.get(key) ?? [];
-    bucket.push(entry);
-    groupedExchange.set(key, bucket);
-  }
-  for (const entry of backtestEntries) {
-    const key = `${entry.symbol}::${entry.direction}`;
-    const bucket = groupedBacktest.get(key) ?? [];
-    bucket.push(entry);
-    groupedBacktest.set(key, bucket);
-  }
-  const matched = [];
-  const exchangeOnly = [];
-  const backtestOnly = [];
-  const matchedBacktestEntries = /* @__PURE__ */ new Set();
-  const groupKeys = /* @__PURE__ */ new Set([
-    ...groupedExchange.keys(),
-    ...groupedBacktest.keys()
-  ]);
-  for (const key of groupKeys) {
-    const exchangeGroup = [...groupedExchange.get(key) ?? []].sort(
-      (left, right) => left.entryTimestamp - right.entryTimestamp
-    );
-    const availableBacktest = [...groupedBacktest.get(key) ?? []].sort(
-      (left, right) => left.timestamp - right.timestamp
-    );
-    const unmatchedBacktest = availableBacktest.map((entry) => ({
-      entry,
-      used: false
-    }));
-    for (const exchangeEntry of exchangeGroup) {
-      let bestIndex = -1;
-      let bestDiff = Number.POSITIVE_INFINITY;
-      for (let index = 0; index < unmatchedBacktest.length; index += 1) {
-        const candidate = unmatchedBacktest[index];
-        if (candidate.used) {
-          continue;
-        }
-        const diff = Math.abs(
-          getBacktestParityComparisonTimestamp(
-            candidate.entry,
-            backtestTimestampOffsetMs
-          ) - exchangeEntry.entryTimestamp
-        );
-        if (diff > toleranceMs || diff >= bestDiff) {
-          continue;
-        }
-        bestIndex = index;
-        bestDiff = diff;
-      }
-      if (bestIndex < 0) {
-        exchangeOnly.push(exchangeEntry);
-        continue;
-      }
-      unmatchedBacktest[bestIndex].used = true;
-      const backtestEntry = unmatchedBacktest[bestIndex].entry;
-      matchedBacktestEntries.add(backtestEntry);
-      matched.push({
-        exchange: exchangeEntry,
-        backtest: backtestEntry,
-        timestampDiffMs: bestDiff,
-        priceDeltaPct: buildPriceDeltaPct3(
-          exchangeEntry.entryPrice,
-          backtestEntry.price
-        )
-      });
-    }
-  }
-  for (const entry of backtestEntries) {
-    if (!matchedBacktestEntries.has(entry)) {
-      backtestOnly.push(entry);
-    }
-  }
-  matched.sort(
-    (left, right) => left.exchange.entryTimestamp - right.exchange.entryTimestamp || left.backtest.strategy.localeCompare(right.backtest.strategy)
-  );
-  exchangeOnly.sort(
-    (left, right) => left.entryTimestamp - right.entryTimestamp
-  );
-  backtestOnly.sort((left, right) => left.timestamp - right.timestamp);
-  return {
-    matched,
-    exchangeOnly,
-    backtestOnly
-  };
-};
-var findExchangeRuntimeOutcome = ({
-  exchangeEntry,
-  strategyName,
-  runtimeSignals,
-  runtimeSignalEvaluations,
-  toleranceMs,
-  signalTimestampOffsetMs
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
+};
+var loadExchangeEntryRows = async ({
+  connector,
+  startTime,
+  endTime
 }) => {
-  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
-      });
-    }
+  if (typeof connector.getEntryExecutions !== "function") {
+    console.log(
+      import_chalk12.default.yellow(
+        "runtime compare: connector does not support entry execution history"
+      )
+    );
+    return [];
   }
-  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
+  const rows = [];
+  const chunks = splitExchangeHistoryTimeRange({ startTime, endTime });
+  for (const chunk of chunks) {
+    try {
+      const chunkRows = await connector.getEntryExecutions({
+        startTime: chunk.startTime,
+        endTime: chunk.endTime,
+        limit: 100
       });
+      if (chunkRows.length >= 100) {
+        console.log(
+          import_chalk12.default.yellow(
+            "runtime compare: exchange entry executions returned 100 rows (connector cap); older entry trades in this chunk may be truncated"
+          )
+        );
+      }
+      rows.push(...chunkRows);
+    } catch (error) {
+      console.log(
+        import_chalk12.default.yellow(
+          `runtime compare: getEntryExecutions failed: ${formatRuntimeTradeSyncError(error)}`
+        )
+      );
     }
   }
-  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;
+  return mergeExchangeEntryExecutions(rows);
 };
-var splitExchangeMatchesByRuntimeOrderStatus = ({
-  matched,
-  strategyNameByOrderLinkKey,
-  runtimeSignals,
-  runtimeSignalEvaluations,
-  toleranceMs,
-  signalTimestampOffsetMs
+var loadExchangeEntriesForComparison = async ({
+  connector,
+  startTime,
+  endTime
 }) => {
-  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;
+  const entryRows = await loadExchangeEntryRows({
+    connector,
+    startTime,
+    endTime
+  });
+  const closedPnlRows = await loadClosedPnlRows({
+    connector,
+    startTime,
+    endTime,
+    callbacks: {
+      onUnsupported: () => {
+        console.log(
+          import_chalk12.default.yellow(
+            "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
+          )
+        );
+      },
+      onCapped: () => {
+        console.log(
+          import_chalk12.default.yellow(
+            "runtime compare: exchange closed pnl returned 100 rows (connector cap); older closed trades in the window may be truncated"
+          )
+        );
+      },
+      onError: (error) => {
+        console.log(
+          import_chalk12.default.yellow(
+            `runtime compare: getClosedPnl failed: ${formatRuntimeTradeSyncError(error)}`
+          )
+        );
+      }
     }
-    orderFailed.push({
-      ...item,
-      reason: outcome.reason || "orderStatus=failed"
-    });
-    return false;
   });
-  return { completed, orderFailed };
+  const closedPnlByOrderId = new Map(
+    closedPnlRows.filter((row) => typeof row.orderId === "string" && row.orderId.trim()).map((row) => [row.orderId, row])
+  );
+  return entryRows.map((entry) => {
+    const closedPnl = typeof entry.orderId === "string" ? closedPnlByOrderId.get(entry.orderId) : null;
+    return {
+      ...entry,
+      exitPrice: closedPnl?.exitPrice ?? entry.exitPrice ?? null,
+      exitTimestamp: closedPnl?.closedAt ?? entry.exitTimestamp ?? null,
+      closedPnl: closedPnl?.closedPnl ?? entry.closedPnl ?? null,
+      openFee: closedPnl?.openFee ?? entry.openFee ?? null,
+      closeFee: closedPnl?.closeFee ?? entry.closeFee ?? null,
+      fundingFee: closedPnl?.fundingFee ?? entry.fundingFee ?? null,
+      totalFee: closedPnl?.totalFee ?? entry.totalFee ?? null
+    };
+  });
 };
 var saveAndPrintReplayExchangeComparison = async ({
   liveStrategySummaries,
@@ -8025,7 +8273,6 @@ 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,
@@ -8034,7 +8281,7 @@ var saveAndPrintReplayExchangeComparison = async ({
     if (!strategyName) {
       return false;
     }
-    const outcome = findExchangeRuntimeOutcome({
+    return hasLineageLinkedRuntimeOutcome({
       exchangeEntry: entry,
       strategyName,
       runtimeSignals,
@@ -8042,24 +8289,18 @@ var saveAndPrintReplayExchangeComparison = async ({
       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 lineage-linked exchange entry executions found for ${connectorName} in ${(0, import_time6.formatUnix)(
-          window.start
-        )} -> ${(0, import_time6.formatUnix)(window.end)}`
-      )
+    writeReplayComparisonReport(
+      buildNoExchangeEntriesReport({
+        connectorName,
+        window
+      })
     );
-    console.log("");
     const details2 = buildReplayExchangeComparisonDetails({
       matched: [],
       exchangeOnly: [],
@@ -8074,6 +8315,16 @@ var saveAndPrintReplayExchangeComparison = async ({
       replaySignals,
       replaySignalEvaluations
     });
+    const emptyRowsByStrategy = new Map(
+      buildExchangeComparisonRows({
+        liveStrategySummaries,
+        backtestEntries,
+        matched: [],
+        orderFailed: [],
+        exchangeOnly: [],
+        strategyNameByOrderLinkKey
+      }).map((row) => [row.strategyName, row])
+    );
     return {
       mode: "exchange",
       syncedTradesCount: 0,
@@ -8086,21 +8337,9 @@ var saveAndPrintReplayExchangeComparison = async ({
       backtestOnlyCount: backtestEntries.length,
       details: details2,
       lineage: comparisonLineage,
-      rows: liveStrategySummaries.map((summary) => ({
-        strategyName: summary.strategyName,
-        backtestEntries: backtestEntries.filter(
-          (entry) => entry.strategy === summary.strategyName
-        ).length,
-        backtestNetProfit: backtestPnlByStrategy.get(summary.strategyName) ?? 0,
-        runtimeTrades: 0,
-        runtimePnl: 0,
-        matched: 0,
-        orderFailed: 0,
-        runtimeOnly: 0,
-        backtestOnly: backtestEntries.filter(
-          (entry) => entry.strategy === summary.strategyName
-        ).length
-      }))
+      rows: liveStrategySummaries.map(
+        ({ strategyName }) => emptyRowsByStrategy.get(strategyName)
+      )
     };
   }
   const comparison = compareExchangeEntriesToBacktest({
@@ -8117,62 +8356,6 @@ var saveAndPrintReplayExchangeComparison = async ({
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
     signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
   });
-  const rowByStrategy = /* @__PURE__ */ new Map();
-  const ensureRow = (strategyName) => {
-    const existing = rowByStrategy.get(strategyName);
-    if (existing) {
-      return existing;
-    }
-    const next = {
-      strategyName,
-      backtestEntries: 0,
-      backtestNetProfit: backtestPnlByStrategy.get(strategyName) ?? 0,
-      runtimeTrades: 0,
-      runtimePnl: 0,
-      matched: 0,
-      orderFailed: 0,
-      runtimeOnly: 0,
-      backtestOnly: 0
-    };
-    rowByStrategy.set(strategyName, next);
-    return next;
-  };
-  for (const summary of liveStrategySummaries) {
-    ensureRow(summary.strategyName);
-  }
-  for (const entry of backtestEntries) {
-    ensureRow(entry.strategy).backtestEntries += 1;
-  }
-  for (const item of matched) {
-    const row = ensureRow(item.backtest.strategy);
-    row.runtimeTrades += 1;
-    row.matched += 1;
-    if (typeof item.exchange.closedPnl === "number" && Number.isFinite(item.exchange.closedPnl)) {
-      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;
-  }
-  if (comparison.exchangeOnly.length) {
-    for (const entry of comparison.exchangeOnly) {
-      const strategyName = resolveReplayStrategyNameFromExchangeEntry({
-        exchangeEntry: entry,
-        strategyNameByOrderLinkKey
-      }) ?? "[exchange-unmatched]";
-      const row = ensureRow(strategyName);
-      row.runtimeTrades += 1;
-      row.runtimeOnly += 1;
-      if (typeof entry.closedPnl === "number" && Number.isFinite(entry.closedPnl)) {
-        row.runtimePnl += entry.closedPnl;
-      }
-    }
-  }
   const details = buildReplayExchangeComparisonDetails({
     matched,
     orderFailed,
@@ -8188,45 +8371,22 @@ var saveAndPrintReplayExchangeComparison = async ({
     replaySignals,
     replaySignalEvaluations
   });
-  const rows = [...rowByStrategy.values()].map((row) => ({
-    ...row,
-    runtimePnl: Number(row.runtimePnl.toFixed(2))
-  })).sort((left, right) => left.strategyName.localeCompare(right.strategyName));
-  const colorizedRows = rows.map((row) => {
-    const btPnlColor = row.backtestNetProfit > 0 ? import_chalk11.default.green : row.backtestNetProfit < 0 ? import_chalk11.default.red : import_chalk11.default.gray;
-    const rtPnlColor = row.runtimePnl > 0 ? import_chalk11.default.green : row.runtimePnl < 0 ? import_chalk11.default.red : import_chalk11.default.gray;
-    return [
-      import_chalk11.default.blue(row.strategyName),
-      import_chalk11.default.cyan(String(row.backtestEntries)),
-      btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
-      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.red(String(getReplayRuntimeUnmatchedCount(row)))
-    ];
+  const rows = buildExchangeComparisonRows({
+    liveStrategySummaries,
+    backtestEntries,
+    matched,
+    orderFailed,
+    exchangeOnly: comparison.exchangeOnly,
+    strategyNameByOrderLinkKey
   });
-  console.log("");
-  console.log(
-    `SIGNALS REPLAY VS EXCHANGE BY STRATEGY (connector=${connectorName}, inferredStrategy=orderLinkId | nearest backtest entry, tolerance=${formatReplayRuntimeCompareTolerance()})`
-  );
-  console.log(createTable(REPLAY_RUNTIME_COMPARISON_HEADERS, colorizedRows));
-  const runtimeOnlyDrilldownSummary = formatDrilldownSummary(
-    details.mismatchDrilldown?.summary.runtimeOnly ?? {}
-  );
-  const backtestOnlyDrilldownSummary = formatDrilldownSummary(
-    details.mismatchDrilldown?.summary.backtestOnly ?? {}
+  writeReplayComparisonReport(
+    buildReplayComparisonReport({
+      mode: "exchange",
+      connectorName,
+      rows,
+      details
+    })
   );
-  if (runtimeOnlyDrilldownSummary || backtestOnlyDrilldownSummary) {
-    console.log(
-      import_chalk11.default.gray(
-        `Mismatch drilldown: exchangeOnly=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
-      )
-    );
-  }
-  console.log("");
   return {
     mode: "exchange",
     syncedTradesCount: exchangeEntries.length,
@@ -8293,7 +8453,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   ]);
   if (runtimeEvidence) {
     console.log(
-      import_chalk11.default.gray(
+      import_chalk12.default.gray(
         `runtime compare: using immutable evidence ${runtimeEvidence.path}`
       )
     );
@@ -8307,7 +8467,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
     openPositionCallbacks: {
       onError: (error) => {
         console.log(
-          import_chalk11.default.yellow(
+          import_chalk12.default.yellow(
             `runtime compare: getOpenPositionPnl failed: ${formatRuntimeTradeSyncError(error)}; continuing without open-position mark prices`
           )
         );
@@ -8316,21 +8476,21 @@ var saveAndPrintReplayRuntimeComparison = async ({
     closedPnlCallbacks: {
       onUnsupported: () => {
         console.log(
-          import_chalk11.default.yellow(
+          import_chalk12.default.yellow(
             "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
           )
         );
       },
       onCapped: () => {
         console.log(
-          import_chalk11.default.yellow(
+          import_chalk12.default.yellow(
             "runtime compare: exchange closed pnl returned 100 rows (connector cap); older closed trades in the window may be truncated"
           )
         );
       },
       onError: (error) => {
         console.log(
-          import_chalk11.default.yellow(
+          import_chalk12.default.yellow(
             `runtime compare: getClosedPnl failed: ${formatRuntimeTradeSyncError(error)}`
           )
         );
@@ -8350,15 +8510,9 @@ var saveAndPrintReplayRuntimeComparison = async ({
     (trade) => trade.entryTimestamp >= window.start && trade.entryTimestamp < window.end && relevantStrategies.has(trade.strategy)
   );
   if (!windowRuntimeTrades.length && !runtimeEvidence) {
-    console.log("");
-    console.log(
-      import_chalk11.default.yellow(
-        `SIGNALS REPLAY VS RUNTIME: no local runtime trades found for ${connectorName} in ${(0, import_time6.formatUnix)(
-          window.start
-        )} -> ${(0, import_time6.formatUnix)(window.end)} with matching lineage; checking lineage-linked exchange executions`
-      )
+    writeReplayComparisonReport(
+      buildNoRuntimeTradesReport({ connectorName, window })
     );
-    console.log("");
     return saveAndPrintReplayExchangeComparison({
       liveStrategySummaries,
       backtestEntries: comparableBacktestEntries,
@@ -8370,9 +8524,6 @@ var saveAndPrintReplayRuntimeComparison = async ({
     });
   }
   const runtimeSummaries = summarizeRuntimeTradesByStrategy(windowRuntimeTrades);
-  const runtimeSummaryByStrategy = new Map(
-    runtimeSummaries.map((summary) => [summary.strategyName, summary])
-  );
   const rawRuntimeEntries = extractRuntimeParityEntries(windowRuntimeTrades);
   const runtimeDedupe = dedupeRuntimeParityEntries(rawRuntimeEntries);
   const comparison = compareTradeParityEntries({
@@ -8402,68 +8553,20 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeOnlyEntries: comparison.runtimeOnly,
     backtestOnlyEntries: comparison.backtestOnly
   });
-  const parityByStrategy = new Map(parityRows);
-  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 runtimeSummary = runtimeSummaryByStrategy.get(strategyName);
-    const parity = parityByStrategy.get(strategyName);
-    return {
-      strategyName,
-      backtestEntries: parity?.backtest ?? 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
-    };
-  });
-  const colorizedRows = rows.map((row) => {
-    const btPnlColor = row.backtestNetProfit > 0 ? import_chalk11.default.green : row.backtestNetProfit < 0 ? import_chalk11.default.red : import_chalk11.default.gray;
-    const rtPnlColor = row.runtimePnl > 0 ? import_chalk11.default.green : row.runtimePnl < 0 ? import_chalk11.default.red : import_chalk11.default.gray;
-    return [
-      import_chalk11.default.blue(row.strategyName),
-      import_chalk11.default.cyan(String(row.backtestEntries)),
-      btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
-      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.red(String(getReplayRuntimeUnmatchedCount(row)))
-    ];
+  const rows = buildRuntimeComparisonRows({
+    liveStrategySummaries,
+    runtimeSummaries,
+    parityRows,
+    backtestEntries: comparableBacktestEntries
   });
-  console.log("");
-  console.log(
-    `SIGNALS REPLAY VS RUNTIME BY STRATEGY (connector=${connectorName}, tolerance=${formatReplayRuntimeCompareTolerance()})`
-  );
-  console.log(createTable(REPLAY_RUNTIME_COMPARISON_HEADERS, colorizedRows));
-  const runtimeOnlyDrilldownSummary = formatDrilldownSummary(
-    details.mismatchDrilldown?.summary.runtimeOnly ?? {}
-  );
-  const backtestOnlyDrilldownSummary = formatDrilldownSummary(
-    details.mismatchDrilldown?.summary.backtestOnly ?? {}
+  writeReplayComparisonReport(
+    buildReplayComparisonReport({
+      mode: "runtime",
+      connectorName,
+      rows,
+      details
+    })
   );
-  if (runtimeOnlyDrilldownSummary || backtestOnlyDrilldownSummary) {
-    console.log(
-      import_chalk11.default.gray(
-        `Mismatch drilldown: runtimeOnly=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
-      )
-    );
-  }
-  console.log("");
   return {
     mode: "runtime",
     syncedTradesCount: syncedRuntimeTrades.length,
@@ -8914,7 +9017,7 @@ var prepareReplayBinanceMarketContext = async (preparedRun) => {
     aiEnabled: preparedRun.aiEnabled,
     mlEnabled: preparedRun.mlEnabled,
     strategyNames: preparedRun.strategyNames,
-    log: (message) => console.log(import_chalk12.default.gray(message))
+    log: (message) => console.log(import_chalk13.default.gray(message))
   });
 };
 var finishReplay = async ({
@@ -8967,8 +9070,8 @@ var finishReplay = async ({
     strategySnapshot: replayStrategySnapshot,
     runtimeComparison: replayRuntimeComparison
   });
-  console.log(import_chalk12.default.green(`Replay report: ${outputReport.markdownPath}`));
-  console.log(import_chalk12.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
+  console.log(import_chalk13.default.green(`Replay report: ${outputReport.markdownPath}`));
+  console.log(import_chalk13.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
   await (0, import_redis6.setData)(
     replayKey,
     {
@@ -9121,9 +9224,9 @@ var replayBacktest = async () => {
     ),
     strategyNames: replayStrategies.map(({ strategyName }) => strategyName)
   });
-  console.log(import_chalk12.default.yellow(`tickers: ${preparedRun.tickers.length}`));
+  console.log(import_chalk13.default.yellow(`tickers: ${preparedRun.tickers.length}`));
   console.log(
-    import_chalk12.default.gray(
+    import_chalk13.default.gray(
       `mode: replay (${replayStrategies.map(({ strategyName }) => strategyName).join(", ")})`
     )
   );