@tradejs/cli 3.1.19 → 3.1.20-beta.236

package/dist/cli.js

@@ -29649,84 +29649,6 @@ var init_runtimeParity = __esm({
   }
 });
 
-// src/lib/paritySummary.ts
-var summarizeRuntimeTradesByStrategy, summarizeTradeParityByStrategy;
-var init_paritySummary = __esm({
-  "src/lib/paritySummary.ts"() {
-    "use strict";
-    summarizeRuntimeTradesByStrategy = (trades) => {
-      const summaryByStrategy = /* @__PURE__ */ new Map();
-      for (const trade of trades) {
-        const summary = summaryByStrategy.get(trade.strategy) ?? {
-          strategyName: trade.strategy,
-          trades: 0,
-          activeTrades: 0,
-          closedTrades: 0,
-          totalPnl: 0
-        };
-        summary.trades += 1;
-        if (trade.status === "active") {
-          summary.activeTrades += 1;
-        } else {
-          summary.closedTrades += 1;
-        }
-        const pnl = trade.status === "active" ? trade.currentPnl : trade.closedPnl ?? trade.currentPnl;
-        if (typeof pnl === "number" && Number.isFinite(pnl)) {
-          summary.totalPnl += pnl;
-        }
-        summaryByStrategy.set(trade.strategy, summary);
-      }
-      return [...summaryByStrategy.values()].map((summary) => ({
-        ...summary,
-        totalPnl: Number(summary.totalPnl.toFixed(2))
-      })).sort((left, right) => left.strategyName.localeCompare(right.strategyName));
-    };
-    summarizeTradeParityByStrategy = ({
-      runtimeEntries,
-      runtimeDuplicateEntries,
-      backtestEntries,
-      matchedEntries,
-      runtimeOnlyEntries,
-      backtestOnlyEntries
-    }) => {
-      const rows = /* @__PURE__ */ new Map();
-      const ensureRow = (strategyName) => {
-        const row = rows.get(strategyName) ?? {
-          runtime: 0,
-          runtimeDuplicates: 0,
-          backtest: 0,
-          matched: 0,
-          runtimeOnly: 0,
-          backtestOnly: 0
-        };
-        rows.set(strategyName, row);
-        return row;
-      };
-      for (const entry of runtimeEntries) {
-        ensureRow(entry.strategy).runtime += 1;
-      }
-      for (const entry of runtimeDuplicateEntries) {
-        ensureRow(entry.strategy).runtimeDuplicates += 1;
-      }
-      for (const entry of backtestEntries) {
-        ensureRow(entry.strategy).backtest += 1;
-      }
-      for (const entry of matchedEntries) {
-        ensureRow(entry.runtime.strategy).matched += 1;
-      }
-      for (const entry of runtimeOnlyEntries) {
-        ensureRow(entry.strategy).runtimeOnly += 1;
-      }
-      for (const entry of backtestOnlyEntries) {
-        ensureRow(entry.strategy).backtestOnly += 1;
-      }
-      return [...rows.entries()].sort(
-        ([left], [right]) => left.localeCompare(right)
-      );
-    };
-  }
-});
-
 // src/lib/runtimeParity/targets.ts
 var parseSymbolsFromCLI2, toTargetKey, buildReplayInputsIndex, addReplayTarget, countReplayTargetSources, buildReplayTargets;
 var init_targets = __esm({
@@ -29848,6 +29770,115 @@ var init_targets = __esm({
   }
 });
 
+// src/lib/runtimeParity/evidence.ts
+var matchesSelection, loadRuntimeParityEvidence;
+var init_evidence = __esm({
+  "src/lib/runtimeParity/evidence.ts"() {
+    "use strict";
+    matchesSelection = (context, artifact) => (!context.strategy || artifact.strategy === context.strategy) && (!context.symbols || context.symbols.has(artifact.symbol));
+    loadRuntimeParityEvidence = async (context, adapters) => {
+      const range = {
+        startTime: context.window.start,
+        endTime: context.window.end
+      };
+      const [allRuntimeTrades, allRuntimeSignals, allRuntimeSignalEvaluations] = await Promise.all([
+        adapters.loadRuntimeTrades(context.userName, range),
+        adapters.loadRuntimeSignals(context.userName, range),
+        adapters.loadRuntimeSignalEvaluations(context.userName, range)
+      ]);
+      return {
+        runtimeTrades: allRuntimeTrades.filter(
+          (trade) => trade.entryTimestamp >= context.window.start && trade.entryTimestamp <= context.window.end && matchesSelection(context, trade)
+        ),
+        runtimeSignals: allRuntimeSignals.filter(
+          (signal) => signal.timestamp >= context.window.start && signal.timestamp <= context.window.end && matchesSelection(context, signal)
+        ),
+        runtimeSignalEvaluations: allRuntimeSignalEvaluations.filter(
+          (evaluation) => evaluation.timestamp >= context.window.start && evaluation.timestamp <= context.window.end && matchesSelection(context, evaluation)
+        )
+      };
+    };
+  }
+});
+
+// src/lib/paritySummary.ts
+var summarizeRuntimeTradesByStrategy, summarizeTradeParityByStrategy;
+var init_paritySummary = __esm({
+  "src/lib/paritySummary.ts"() {
+    "use strict";
+    summarizeRuntimeTradesByStrategy = (trades) => {
+      const summaryByStrategy = /* @__PURE__ */ new Map();
+      for (const trade of trades) {
+        const summary = summaryByStrategy.get(trade.strategy) ?? {
+          strategyName: trade.strategy,
+          trades: 0,
+          activeTrades: 0,
+          closedTrades: 0,
+          totalPnl: 0
+        };
+        summary.trades += 1;
+        if (trade.status === "active") {
+          summary.activeTrades += 1;
+        } else {
+          summary.closedTrades += 1;
+        }
+        const pnl = trade.status === "active" ? trade.currentPnl : trade.closedPnl ?? trade.currentPnl;
+        if (typeof pnl === "number" && Number.isFinite(pnl)) {
+          summary.totalPnl += pnl;
+        }
+        summaryByStrategy.set(trade.strategy, summary);
+      }
+      return [...summaryByStrategy.values()].map((summary) => ({
+        ...summary,
+        totalPnl: Number(summary.totalPnl.toFixed(2))
+      })).sort((left, right) => left.strategyName.localeCompare(right.strategyName));
+    };
+    summarizeTradeParityByStrategy = ({
+      runtimeEntries,
+      runtimeDuplicateEntries,
+      backtestEntries,
+      matchedEntries,
+      runtimeOnlyEntries,
+      backtestOnlyEntries
+    }) => {
+      const rows = /* @__PURE__ */ new Map();
+      const ensureRow = (strategyName) => {
+        const row = rows.get(strategyName) ?? {
+          runtime: 0,
+          runtimeDuplicates: 0,
+          backtest: 0,
+          matched: 0,
+          runtimeOnly: 0,
+          backtestOnly: 0
+        };
+        rows.set(strategyName, row);
+        return row;
+      };
+      for (const entry of runtimeEntries) {
+        ensureRow(entry.strategy).runtime += 1;
+      }
+      for (const entry of runtimeDuplicateEntries) {
+        ensureRow(entry.strategy).runtimeDuplicates += 1;
+      }
+      for (const entry of backtestEntries) {
+        ensureRow(entry.strategy).backtest += 1;
+      }
+      for (const entry of matchedEntries) {
+        ensureRow(entry.runtime.strategy).matched += 1;
+      }
+      for (const entry of runtimeOnlyEntries) {
+        ensureRow(entry.strategy).runtimeOnly += 1;
+      }
+      for (const entry of backtestOnlyEntries) {
+        ensureRow(entry.strategy).backtestOnly += 1;
+      }
+      return [...rows.entries()].sort(
+        ([left], [right]) => left.localeCompare(right)
+      );
+    };
+  }
+});
+
 // src/lib/runtimeParity/classification.ts
 var BACKTEST_ONLY_CLASSIFICATIONS, RUNTIME_ONLY_CLASSIFICATIONS, formatMinutes, normalizeSignalOrderStatus, findNearestRuntimeSignal, findNearestRuntimeSignalEvaluation, findNearestBacktestEntryForRuntimeOnly, buildSignalClassificationReason, buildEvaluationClassification, buildRuntimeOnlyEvaluationClassification, classifyBacktestOnlyEntries, classifyRuntimeOnlyEntries, summarizeBacktestOnlyClassifications, summarizeRuntimeOnlyClassifications;
 var init_classification = __esm({
@@ -30183,262 +30214,131 @@ var init_classification = __esm({
   }
 });
 
-// src/scripts/runtimeParity.ts
-var runtimeParity_exports = {};
-__export(runtimeParity_exports, {
-  buildRuntimeParityMessage: () => buildRuntimeParityMessage,
-  main: () => main40,
-  runtimeParity: () => runtimeParity
-});
-var import_config11, import_node_crypto14, import_args30, import_chalk43, import_constants15, import_time7, import_logger6, import_redis17, import_cli11, import_backtest3, import_connectors14, flags28, interval3, projectRoot13, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT, TELEGRAM_DETAIL_LIMIT, SUMMARY_TIMEZONE, SUMMARY_TIMEZONE_LABEL, DEFAULT_REPLAY_ENV, escapeHtml5, formatMskDateTime2, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, formatPercent4, formatMinutes2, formatEntryLabel, formatRuntimeEntriesSummary, formatSourceCountsSummary, normalizeSummaryText, pickFirstText, buildMismatchSummaryRows, buildStrategyIssueRows, toSerializableTradeParityEntry, toSerializableSignal, toSerializableRuntimeSignalEvaluation, getRuntimeOnlyLikelyCause, getBacktestOnlyLikelyCause, getRuntimeOnlyRecommendedChecks, getBacktestOnlyRecommendedChecks, buildRuntimeParityMismatchAttachment, printRuntimeDuplicateDetails, printClassifiedBacktestOnlyDetails, printClassifiedRuntimeOnlyDetails, summarizeByStrategy, buildRuntimeParityMessage, buildRuntimeParityNoTargetsMessage, runtimeParity, main40;
-var init_runtimeParity2 = __esm({
-  "src/scripts/runtimeParity.ts"() {
+// src/lib/runtimeParity/analysis.ts
+var summarizeByStrategy, analyzeRuntimeParity;
+var init_analysis = __esm({
+  "src/lib/runtimeParity/analysis.ts"() {
     "use strict";
-    import_config11 = require("dotenv/config");
-    import_node_crypto14 = require("crypto");
-    import_args30 = __toESM(require("args"));
-    import_chalk43 = __toESM(require("chalk"));
-    import_constants15 = require("@tradejs/core/constants");
-    import_time7 = require("@tradejs/core/time");
-    import_logger6 = require("@tradejs/infra/logger");
-    import_redis17 = require("@tradejs/infra/redis");
-    import_cli11 = require("@tradejs/node/cli");
-    import_backtest3 = require("@tradejs/node/backtest");
-    import_connectors14 = require("@tradejs/node/connectors");
     init_runtimeParity();
-    init_cliArgs();
     init_paritySummary();
-    init_runtimeRedis();
-    init_runtimeSignalsLoader();
-    init_telegramReports();
-    init_timeWindow();
-    init_runFormatting();
-    init_marketContextPrepare();
-    init_historyPrepare();
-    init_targets();
     init_classification();
-    init_runtimeModeConfig();
-    import_args30.default.option(["u", "user"], "Use user config", "root");
-    import_args30.default.option(
-      ["o", "connector"],
-      "Connector provider or name for parity replay (e.g. bybit, binance, coinbase, custom)",
-      "bybit"
-    );
-    import_args30.default.option(["d", "days"], "Replay window in days", 3);
-    import_args30.default.option(
-      ["b", "startTime"],
-      "Explicit replay start timestamp (ms or seconds)"
-    );
-    import_args30.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
-    import_args30.default.option(["s", "strategy"], "Only compare one strategy");
-    import_args30.default.option(
-      ["t", "tickers"],
-      "Replay comma-separated symbols for all configured strategies"
-    );
-    import_args30.default.option(
-      ["C", "cacheOnly"],
-      "Do not refresh market history before replay",
-      false
-    );
-    import_args30.default.option(
-      ["a", "toleranceBars"],
-      "Allowed entry timestamp drift in bars when matching runtime vs backtest",
-      1
-    );
-    import_args30.default.option(
-      "fullUniverse",
-      "Replay every configured strategy across the full connector universe. By default parity replays only runtime-traded and strategy-results symbols unless --tickers is provided.",
-      false
-    );
-    import_args30.default.option(
-      "runtimeGates",
-      "Force runtime AI/ML gates for all replay targets. Runtime-gated configs are replayed with gates by default.",
-      false
-    );
-    import_args30.default.option(["N", "notify"], "Send parity summary to Telegram", false);
-    import_args30.default.option(["D", "details"], "Print unmatched entry details (capped)", false);
-    process.argv = normalizeCliArgv(process.argv, {
-      "-C": "--cacheOnly",
-      "-D": "--details",
-      "-E": "--endTime",
-      "-N": "--notify",
-      "-S": "--startTime",
-      "-T": "--toleranceBars"
-    });
-    flags28 = import_args30.default.parse(process.argv);
-    interval3 = "15";
-    projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
-    DEFAULT_LOOKBACK_DAYS = 3;
-    DETAIL_LIMIT = 10;
-    TELEGRAM_DETAIL_LIMIT = 5;
-    SUMMARY_TIMEZONE = "Europe/Moscow";
-    SUMMARY_TIMEZONE_LABEL = "MSK";
-    DEFAULT_REPLAY_ENV = flags28.runtimeGates ? "PARITY" : "BACKTEST";
-    escapeHtml5 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    formatMskDateTime2 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
-      timeZone: SUMMARY_TIMEZONE,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      hour12: false
-    }).format(new Date(timestamp));
-    resolveParityConnectorName = async (value) => {
-      const connectorName = await (0, import_connectors14.resolveConnectorName)(value, projectRoot13);
-      if (connectorName) {
-        return connectorName;
-      }
-      import_logger6.logger.warn(
-        'Unknown connector "%s". Fallback to %s.',
-        String(value || "").trim() || String(value),
-        import_connectors14.DEFAULT_CONNECTOR_NAME
-      );
-      return import_connectors14.DEFAULT_CONNECTOR_NAME;
-    };
-    createConnector = async ({
-      userName: userName3,
-      connectorName
-    }) => {
-      const connectorFactory = await (0, import_connectors14.getConnectorCreatorByName)(
-        connectorName,
-        projectRoot13
-      );
-      if (!connectorFactory) {
-        throw new Error(`Connector "${connectorName}" is not registered`);
-      }
-      return await connectorFactory({ userName: userName3 });
-    };
-    buildReplayAiAnalyses = ({
-      runtimeTrades,
-      runtimeSignalEvaluations,
-      toleranceMs
+    init_targets();
+    summarizeByStrategy = ({
+      targets,
+      successfulTargetKeys,
+      replayErrors,
+      runtimeEntries,
+      runtimeDuplicateEntries,
+      backtestEntries,
+      matchedEntries,
+      runtimeOnlyEntries,
+      backtestOnlyEntries
     }) => {
-      const snapshots = [
-        ...runtimeTrades.filter(
-          (trade) => trade.aiAnalysis && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp)
-        ).map((trade) => ({
-          strategy: trade.strategy,
-          symbol: trade.symbol,
-          direction: trade.direction,
-          timestamp: trade.entryTimestamp,
-          toleranceMs,
-          analysis: trade.aiAnalysis
-        })),
-        ...runtimeSignalEvaluations.filter(
-          (evaluation) => evaluation.aiAnalysis && evaluation.direction && typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp)
-        ).map((evaluation) => ({
-          strategy: evaluation.strategy,
-          symbol: evaluation.symbol,
-          direction: evaluation.direction,
-          timestamp: evaluation.timestamp,
-          toleranceMs,
-          analysis: evaluation.aiAnalysis
-        }))
-      ];
-      const seen = /* @__PURE__ */ new Set();
-      return snapshots.filter((snapshot) => {
-        const key = `${snapshot.strategy}:${snapshot.symbol}:${snapshot.direction}:${snapshot.timestamp}`;
-        if (seen.has(key)) {
-          return false;
-        }
-        seen.add(key);
-        return true;
+      const rows = /* @__PURE__ */ new Map();
+      const baseRows = summarizeTradeParityByStrategy({
+        runtimeEntries,
+        runtimeDuplicateEntries,
+        backtestEntries,
+        matchedEntries,
+        runtimeOnlyEntries,
+        backtestOnlyEntries
       });
-    };
-    formatReplayEnvSummary = (configs) => {
-      let backtest2 = 0;
-      let parity = 0;
-      for (const config2 of configs) {
-        if (config2.ENV === "PARITY") {
-          parity += 1;
-        } else {
-          backtest2 += 1;
-        }
+      for (const [strategy, baseRow] of baseRows) {
+        rows.set(strategy, {
+          ...baseRow,
+          targets: 0,
+          compared: 0,
+          errors: 0
+        });
       }
-      if (parity > 0 && backtest2 > 0) {
-        return `MIXED (PARITY=${parity}, BACKTEST=${backtest2})`;
+      const ensureRow = (strategy) => {
+        const row = rows.get(strategy) ?? {
+          runtime: 0,
+          runtimeDuplicates: 0,
+          backtest: 0,
+          matched: 0,
+          runtimeOnly: 0,
+          backtestOnly: 0,
+          targets: 0,
+          compared: 0,
+          errors: 0
+        };
+        rows.set(strategy, row);
+        return row;
+      };
+      for (const target of targets) {
+        const row = ensureRow(target.strategy);
+        row.targets += 1;
+        if (successfulTargetKeys.has(toTargetKey(target))) {
+          row.compared += 1;
+        }
       }
-      if (parity > 0) {
-        return "PARITY";
+      for (const error of replayErrors) {
+        ensureRow(error.strategy).errors += 1;
       }
-      return "BACKTEST";
-    };
-    buildReplayConfig = async ({
-      userName: userName3,
-      strategy,
-      symbol,
-      replayInputsIndex,
-      toleranceMs
-    }) => {
-      const [userConfig, strategyResults] = await Promise.all([
-        (0, import_redis17.getData)(import_redis17.redisKeys.strategyConfig(userName3, strategy), {}),
-        (0, import_redis17.getData)(import_redis17.redisKeys.strategyResults(userName3, strategy), {})
-      ]);
-      const typedResults = strategyResults ?? {};
-      const symbolResult = typedResults?.[symbol];
-      const symbolConfig = symbolResult && symbolResult.config && typeof symbolResult.config === "object" ? symbolResult.config : {};
-      const replayInputs = replayInputsIndex.get(toTargetKey({ strategy, symbol }));
-      const aiReplayAnalyses = buildReplayAiAnalyses({
-        runtimeTrades: replayInputs?.runtimeTrades ?? [],
-        runtimeSignalEvaluations: replayInputs?.runtimeSignalEvaluations ?? [],
-        strategy,
-        symbol,
-        toleranceMs
-      });
-      const strategyConfig = {
-        ...userConfig,
-        ...symbolConfig
-      };
-      return buildRuntimeModeStrategyConfig({
-        strategyConfig,
-        env: resolveReplayStrategyEnv({
-          strategyConfig,
-          forceRuntimeGates: Boolean(flags28.runtimeGates)
-        }),
-        interval: interval3,
-        makeOrders: true,
-        recordRuntimeTrades: false,
-        aiReplayAnalyses
-      });
+      return [...rows.entries()].sort(
+        ([left], [right]) => left.localeCompare(right)
+      );
     };
-    warmReplayHistory = async ({
-      userName: userName3,
-      connectorName,
-      targets,
-      preloadStart,
-      preloadEnd
-    }) => {
-      const connector = await createConnector({ userName: userName3, connectorName });
-      const symbols = [...new Set(targets.map((target) => target.symbol))];
-      const warmStartedAt = Date.now();
-      console.log(
-        import_chalk43.default.gray(
-          `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time7.formatUnix)(preloadStart)} -> ${(0, import_time7.formatUnix)(preloadEnd)}`
-        )
+    analyzeRuntimeParity = (context) => {
+      const comparableRuntimeTrades = context.runtimeTrades.filter(
+        (trade) => context.successfulTargetKeys.has(toTargetKey(trade))
       );
-      const btcReferences = await loadBtcReferenceConnectors({
-        connectorName,
-        marketConnector: connector,
-        userName: userName3,
-        projectRoot: projectRoot13,
-        shouldUseDedicatedReferences: true,
-        warn: (message) => import_logger6.logger.warn(message)
-      });
-      await updateMarketHistoryWithBtcReferences({
-        marketConnector: connector,
-        connectorName,
-        btcReferences,
-        interval: interval3,
-        symbols,
-        preloadStart,
-        preloadEnd,
-        log: (message) => console.log(import_chalk43.default.gray(message))
-      });
-      console.log(
-        import_chalk43.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
+      const rawRuntimeEntries = extractRuntimeParityEntries(
+        comparableRuntimeTrades
       );
+      const runtimeDedupe = dedupeRuntimeParityEntries(rawRuntimeEntries);
+      const runtimeEntries = runtimeDedupe.entries;
+      const comparison = compareTradeParityEntries({
+        runtimeEntries,
+        backtestEntries: context.backtestEntries,
+        toleranceMs: context.toleranceMs
+      });
+      const classifiedBacktestOnly = classifyBacktestOnlyEntries({
+        entries: comparison.backtestOnly,
+        runtimeSignals: context.runtimeSignals,
+        runtimeSignalEvaluations: context.runtimeSignalEvaluations,
+        toleranceMs: context.toleranceMs
+      });
+      const classifiedRuntimeOnly = classifyRuntimeOnlyEntries({
+        entries: comparison.runtimeOnly,
+        replaySignalEvaluations: context.replaySignalEvaluations,
+        backtestEntries: context.backtestEntries,
+        toleranceMs: context.toleranceMs
+      });
+      const matchedSummary = summarizeMatchedParity(comparison.matched);
+      const strategyRows = summarizeByStrategy({
+        targets: context.replayTargets,
+        successfulTargetKeys: context.successfulTargetKeys,
+        replayErrors: context.replayErrors,
+        runtimeEntries,
+        runtimeDuplicateEntries: runtimeDedupe.duplicateEntries,
+        backtestEntries: context.backtestEntries,
+        matchedEntries: comparison.matched,
+        runtimeOnlyEntries: comparison.runtimeOnly,
+        backtestOnlyEntries: comparison.backtestOnly
+      });
+      return {
+        comparableRuntimeTrades,
+        rawRuntimeEntries,
+        runtimeDedupe,
+        runtimeEntries,
+        comparison,
+        classifiedBacktestOnly,
+        classifiedRuntimeOnly,
+        matchedSummary,
+        strategyRows
+      };
     };
+  }
+});
+
+// src/lib/runtimeParity/reportingShared.ts
+var import_time7, formatPercent4, formatMinutes2, formatEntryLabel, formatRuntimeEntriesSummary, formatSourceCountsSummary, normalizeSummaryText, pickFirstText, buildMismatchSummaryRows, buildStrategyIssueRows;
+var init_reportingShared = __esm({
+  "src/lib/runtimeParity/reportingShared.ts"() {
+    "use strict";
+    import_time7 = require("@tradejs/core/time");
     formatPercent4 = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${value.toFixed(2)}%`;
     formatMinutes2 = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${(value / 6e4).toFixed(2)}m`;
     formatEntryLabel = (entry) => `${entry.strategy} ${entry.symbol} ${entry.direction} ${(0, import_time7.formatUnix)(entry.timestamp)}`;
@@ -30458,16 +30358,11 @@ var init_runtimeParity2 = __esm({
     };
     normalizeSummaryText = (value, maxLength = 160) => {
       const normalized = value.replace(/\s+/g, " ").trim();
-      if (normalized.length <= maxLength) {
-        return normalized;
-      }
-      return `${normalized.slice(0, maxLength - 3)}...`;
+      return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3)}...`;
     };
     pickFirstText = (...values) => {
       for (const value of values) {
-        if (typeof value === "string" && value.trim()) {
-          return value.trim();
-        }
+        if (typeof value === "string" && value.trim()) return value.trim();
       }
       return null;
     };
@@ -30487,9 +30382,7 @@ var init_runtimeParity2 = __esm({
           item.nearestBacktestEntry?.id
         );
         const refs = [`signalId=${signalId ?? "n/a"}`];
-        if (orderId && orderId !== signalId) {
-          refs.push(`orderId=${orderId}`);
-        }
+        if (orderId && orderId !== signalId) refs.push(`orderId=${orderId}`);
         if (item.evaluation?.evaluationId) {
           refs.push(`evaluationId=${item.evaluation.evaluationId}`);
         }
@@ -30551,20 +30444,23 @@ var init_runtimeParity2 = __esm({
     };
     buildStrategyIssueRows = (strategyRows) => strategyRows.map(([strategy, row]) => {
       const issues = [];
-      if (row.runtimeOnly) {
-        issues.push(`runtimeOnly=${row.runtimeOnly}`);
-      }
-      if (row.backtestOnly) {
-        issues.push(`backtestOnly=${row.backtestOnly}`);
-      }
+      if (row.runtimeOnly) issues.push(`runtimeOnly=${row.runtimeOnly}`);
+      if (row.backtestOnly) issues.push(`backtestOnly=${row.backtestOnly}`);
       if (row.runtimeDuplicates) {
         issues.push(`runtimeDuplicates=${row.runtimeDuplicates}`);
       }
-      if (row.errors) {
-        issues.push(`errors=${row.errors}`);
-      }
+      if (row.errors) issues.push(`errors=${row.errors}`);
       return issues.length ? `- ${strategy}: ${issues.join(", ")}` : null;
     }).filter((line) => Boolean(line));
+  }
+});
+
+// src/lib/runtimeParity/reportingJson.ts
+var toSerializableTradeParityEntry, toSerializableSignal, toSerializableRuntimeSignalEvaluation, getRuntimeOnlyLikelyCause, getBacktestOnlyLikelyCause, getRuntimeOnlyRecommendedChecks, getBacktestOnlyRecommendedChecks, buildRuntimeParityMismatchAttachment;
+var init_reportingJson = __esm({
+  "src/lib/runtimeParity/reportingJson.ts"() {
+    "use strict";
+    init_reportingShared();
     toSerializableTradeParityEntry = (entry) => entry ? {
       id: entry.id,
       source: entry.source,
@@ -30707,34 +30603,12 @@ var init_runtimeParity2 = __esm({
           ];
       }
     };
-    buildRuntimeParityMismatchAttachment = ({
-      window,
-      connectorName,
-      replayEnv,
-      toleranceBars,
-      toleranceMs,
-      replayTargetsCount,
-      comparedTargetsCount,
-      replayErrors,
-      sourceCounts,
-      rawRuntimeEntriesCount,
-      runtimeEntriesCount,
-      runtimeDuplicateEntriesCount,
-      backtestEntriesCount,
-      matchedCount,
-      runtimeOnlyCount,
-      backtestOnlyCount,
-      matchedSummary,
-      classifiedRuntimeOnly,
-      classifiedBacktestOnly,
-      runtimeSignalEvaluationsCount,
-      strategyRows
-    }) => {
-      if (!classifiedRuntimeOnly.length && !classifiedBacktestOnly.length) {
+    buildRuntimeParityMismatchAttachment = (context) => {
+      if (!context.classifiedRuntimeOnly.length && !context.classifiedBacktestOnly.length) {
         return null;
       }
       const cases = [
-        ...classifiedRuntimeOnly.map((item) => ({
+        ...context.classifiedRuntimeOnly.map((item) => ({
           kind: "runtimeOnly",
           strategy: item.entry.strategy,
           symbol: item.entry.symbol,
@@ -30773,7 +30647,7 @@ var init_runtimeParity2 = __esm({
             )
           }
         })),
-        ...classifiedBacktestOnly.map((item) => ({
+        ...context.classifiedBacktestOnly.map((item) => ({
           kind: "backtestOnly",
           strategy: item.entry.strategy,
           symbol: item.entry.symbol,
@@ -30819,40 +30693,37 @@ var init_runtimeParity2 = __esm({
         generatedAt: Date.now(),
         codexQuestion: "For each mismatch case, explain why runtime and replay/backtest diverged. Use why.classification first, then confirm with decisionTrace, timing, and artifacts.",
         window: {
-          start: window.start,
-          end: window.end,
-          source: window.source
-        },
-        connectorName,
-        replayEnv,
-        tolerance: {
-          bars: toleranceBars,
-          ms: toleranceMs
+          start: context.window.start,
+          end: context.window.end,
+          source: context.window.source
         },
+        connectorName: context.connectorName,
+        replayEnv: context.replayEnv,
+        tolerance: { bars: context.toleranceBars, ms: context.toleranceMs },
         summary: {
-          replayTargets: replayTargetsCount,
-          comparedTargets: comparedTargetsCount,
-          replayErrors: replayErrors.length,
-          sourceCounts,
-          runtimeEntriesRaw: rawRuntimeEntriesCount,
-          runtimeEntries: runtimeEntriesCount,
-          runtimeDuplicateEntries: runtimeDuplicateEntriesCount,
-          backtestEntries: backtestEntriesCount,
-          matchedEntries: matchedCount,
-          runtimeOnlyEntries: runtimeOnlyCount,
-          backtestOnlyEntries: backtestOnlyCount,
-          runtimeSignalEvaluations: runtimeSignalEvaluationsCount,
+          replayTargets: context.replayTargetsCount,
+          comparedTargets: context.comparedTargetsCount,
+          replayErrors: context.replayErrors.length,
+          sourceCounts: context.sourceCounts,
+          runtimeEntriesRaw: context.rawRuntimeEntriesCount,
+          runtimeEntries: context.runtimeEntriesCount,
+          runtimeDuplicateEntries: context.runtimeDuplicateEntriesCount,
+          backtestEntries: context.backtestEntriesCount,
+          matchedEntries: context.matchedCount,
+          runtimeOnlyEntries: context.runtimeOnlyCount,
+          backtestOnlyEntries: context.backtestOnlyCount,
+          runtimeSignalEvaluations: context.runtimeSignalEvaluationsCount,
           matchedDeltas: {
-            priceAvgPct: matchedSummary.avgPriceDeltaPct,
-            priceMaxPct: matchedSummary.maxPriceDeltaPct,
-            timeAvgMs: matchedSummary.avgTimestampDiffMs,
-            timeMaxMs: matchedSummary.maxTimestampDiffMs
+            priceAvgPct: context.matchedSummary.avgPriceDeltaPct,
+            priceMaxPct: context.matchedSummary.maxPriceDeltaPct,
+            timeAvgMs: context.matchedSummary.avgTimestampDiffMs,
+            timeMaxMs: context.matchedSummary.maxTimestampDiffMs
           },
-          strategyIssues: buildStrategyIssueRows(strategyRows).map(
+          strategyIssues: buildStrategyIssueRows(context.strategyRows).map(
             (line) => line.slice(2)
           )
         },
-        replayErrors: replayErrors.map((error) => ({
+        replayErrors: context.replayErrors.map((error) => ({
           strategy: error.strategy,
           symbol: error.symbol,
           sources: error.sources,
@@ -30860,7 +30731,7 @@ var init_runtimeParity2 = __esm({
         })),
         cases,
         mismatches: {
-          runtimeOnly: classifiedRuntimeOnly.map((item) => ({
+          runtimeOnly: context.classifiedRuntimeOnly.map((item) => ({
             classification: item.classification,
             reason: item.reason,
             runtimeEntry: toSerializableTradeParityEntry(item.entry),
@@ -30873,7 +30744,7 @@ var init_runtimeParity2 = __esm({
             ),
             nearestBacktestDriftMs: item.nearestBacktestEntryTimestampDiffMs
           })),
-          backtestOnly: classifiedBacktestOnly.map((item) => ({
+          backtestOnly: context.classifiedBacktestOnly.map((item) => ({
             classification: item.classification,
             reason: item.reason,
             backtestEntry: toSerializableTradeParityEntry(item.entry),
@@ -30887,31 +30758,115 @@ var init_runtimeParity2 = __esm({
         }
       };
       return {
-        filename: `runtime-parity-mismatches-${connectorName}-${window.start}-${window.end}.json`,
+        filename: `runtime-parity-mismatches-${context.connectorName}-${context.window.start}-${context.window.end}.json`,
         content: JSON.stringify(payload, null, 2),
         caption: "Runtime parity mismatch JSON"
       };
     };
-    printRuntimeDuplicateDetails = (groups) => {
-      if (!groups.length) {
-        return;
-      }
-      console.log("");
-      console.log(import_chalk43.default.yellow("Runtime duplicates"));
-      for (const group of groups.slice(0, DETAIL_LIMIT)) {
-        const ids = group.entries.map((entry) => entry.orderId ?? entry.id);
-        console.log(
-          `- ${formatEntryLabel(group.entries[0])} count=${group.entries.length}, duplicateEntries=${group.entries.length - 1}, ids=${ids.join(",")}`
-        );
-      }
-      if (groups.length > DETAIL_LIMIT) {
+  }
+});
+
+// src/lib/runtimeParity/reportingTerminal.ts
+var import_chalk43, import_time8, DETAIL_LIMIT, buildRuntimeParityTerminalReport, writeRuntimeParityTerminalReport, printRuntimeDuplicateDetails, printClassifiedBacktestOnlyDetails, printClassifiedRuntimeOnlyDetails;
+var init_reportingTerminal = __esm({
+  "src/lib/runtimeParity/reportingTerminal.ts"() {
+    "use strict";
+    import_chalk43 = __toESM(require("chalk"));
+    import_time8 = require("@tradejs/core/time");
+    init_classification();
+    init_reportingShared();
+    DETAIL_LIMIT = 10;
+    buildRuntimeParityTerminalReport = (context) => {
+      const mismatchRows = buildMismatchSummaryRows(context);
+      const strategyIssueRows = buildStrategyIssueRows(context.strategyRows);
+      const lines = [
+        import_chalk43.default.cyan("TradeJS runtime parity"),
+        `Window: ${(0, import_time8.formatUnix)(context.window.start)} -> ${(0, import_time8.formatUnix)(context.window.end)} (${context.window.source})`,
+        `Connector: ${context.connectorName}`,
+        `Replay env: ${context.replayEnv}${context.runtimeGatesEnabled ? " (runtime AI/ML gates enabled)" : " (core/backtest gates only)"}`,
+        `Tolerance: ${context.toleranceBars} bar(s) / ${(context.toleranceMs / 6e4).toFixed(0)}m`,
+        `Summary: targets=${context.replayTargetsCount}, compared=${context.comparedTargetsCount}, errors=${context.replayErrors.length}, runtime=${context.runtimeEntriesCount}, backtest=${context.backtestEntriesCount}, runtimeOnly=${context.runtimeOnlyCount}, backtestOnly=${context.backtestOnlyCount}, evaluations=${context.runtimeSignalEvaluationsCount}`,
+        `Sources: ${formatSourceCountsSummary(context.sourceCounts)}`,
+        `Runtime entries: ${formatRuntimeEntriesSummary(context)}`,
+        `Matched deltas: price avg/max=${formatPercent4(context.matchedSummary.avgPriceDeltaPct)} / ${formatPercent4(context.matchedSummary.maxPriceDeltaPct)}, time avg/max=${formatMinutes2(context.matchedSummary.avgTimestampDiffMs)} / ${formatMinutes2(context.matchedSummary.maxTimestampDiffMs)}`
+      ];
+      if (context.runtimeDuplicateGroupsCount) {
+        lines.push(
+          `Runtime duplicate groups: ${context.runtimeDuplicateGroupsCount}, duplicate entries: ${context.runtimeDuplicateEntriesCount}`
+        );
+      }
+      if (context.classifiedRuntimeOnly.length) {
+        lines.push(
+          `Runtime only classifications: ${summarizeRuntimeOnlyClassifications(context.classifiedRuntimeOnly)}`
+        );
+      }
+      if (context.classifiedBacktestOnly.length) {
+        lines.push(
+          `Backtest only classifications: ${summarizeBacktestOnlyClassifications(context.classifiedBacktestOnly)}`
+        );
+      }
+      if (context.runtimeSignalEvaluationsCount) {
+        lines.push(`Runtime evaluations: ${context.runtimeSignalEvaluationsCount}`);
+      }
+      if (mismatchRows.length) {
+        lines.push("", import_chalk43.default.yellow("Signal mismatches"));
+        for (const item of mismatchRows.slice(0, context.detailLimit)) {
+          lines.push(`- ${item.line}`);
+        }
+        if (mismatchRows.length > context.detailLimit) {
+          lines.push(`- ... ${mismatchRows.length - context.detailLimit} more`);
+        }
+      }
+      lines.push("");
+      if (strategyIssueRows.length) {
+        lines.push(import_chalk43.default.cyan("Strategy issues"), ...strategyIssueRows);
+      } else if (context.strategyRows.length) {
+        lines.push(
+          `Strategies: clean ${context.strategyRows.length}/${context.strategyRows.length}`
+        );
+      }
+      if (context.runtimeGateWarningCounts.size && !context.runtimeGatesRequested) {
+        lines.push("", import_chalk43.default.yellow("Warnings"));
+        for (const [strategy, count] of [
+          ...context.runtimeGateWarningCounts.entries()
+        ].sort(([left], [right]) => left.localeCompare(right))) {
+          lines.push(
+            `- ${strategy} uses AI/ML runtime gates on ${count} replay target(s); BACKTEST replay covers core execution, not live gating.`
+          );
+        }
+      }
+      if (context.replayErrors.length) {
+        lines.push("", import_chalk43.default.red("Replay errors"));
+        for (const error of context.replayErrors.slice(0, context.detailLimit)) {
+          lines.push(`- ${error.strategy} ${error.symbol}: ${error.message}`);
+        }
+        if (context.replayErrors.length > context.detailLimit) {
+          lines.push(
+            `- ... ${context.replayErrors.length - context.detailLimit} more`
+          );
+        }
+      }
+      return lines;
+    };
+    writeRuntimeParityTerminalReport = (lines) => {
+      for (const line of lines) console.log(line);
+    };
+    printRuntimeDuplicateDetails = (groups) => {
+      if (!groups.length) return;
+      console.log("");
+      console.log(import_chalk43.default.yellow("Runtime duplicates"));
+      for (const group of groups.slice(0, DETAIL_LIMIT)) {
+        const ids = group.entries.map((entry) => entry.orderId ?? entry.id);
+        console.log(
+          `- ${formatEntryLabel(group.entries[0])} count=${group.entries.length}, duplicateEntries=${group.entries.length - 1}, ids=${ids.join(",")}`
+        );
+      }
+      if (groups.length > DETAIL_LIMIT) {
         console.log(`- ... ${groups.length - DETAIL_LIMIT} more`);
       }
     };
     printClassifiedBacktestOnlyDetails = (classifiedEntries) => {
-      if (!classifiedEntries.length) {
-        return;
-      }
+      if (!classifiedEntries.length) return;
       console.log("");
       console.log(import_chalk43.default.yellow("Backtest only"));
       for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
@@ -30926,9 +30881,7 @@ var init_runtimeParity2 = __esm({
       }
     };
     printClassifiedRuntimeOnlyDetails = (classifiedEntries) => {
-      if (!classifiedEntries.length) {
-        return;
-      }
+      if (!classifiedEntries.length) return;
       console.log("");
       console.log(import_chalk43.default.yellow("Runtime only"));
       for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
@@ -30942,149 +30895,86 @@ var init_runtimeParity2 = __esm({
         console.log(`- ... ${classifiedEntries.length - DETAIL_LIMIT} more`);
       }
     };
-    summarizeByStrategy = ({
-      targets,
-      successfulTargetKeys,
-      replayErrors,
-      runtimeEntries,
-      runtimeDuplicateEntries,
-      backtestEntries,
-      matchedEntries,
-      runtimeOnlyEntries,
-      backtestOnlyEntries
-    }) => {
-      const rows = /* @__PURE__ */ new Map();
-      const baseRows = summarizeTradeParityByStrategy({
-        runtimeEntries,
-        runtimeDuplicateEntries,
-        backtestEntries,
-        matchedEntries,
-        runtimeOnlyEntries,
-        backtestOnlyEntries
-      });
-      for (const [strategy, baseRow] of baseRows) {
-        rows.set(strategy, {
-          ...baseRow,
-          targets: 0,
-          compared: 0,
-          errors: 0
-        });
-      }
-      const ensureRow = (strategy) => {
-        const row = rows.get(strategy) ?? {
-          runtime: 0,
-          runtimeDuplicates: 0,
-          backtest: 0,
-          matched: 0,
-          runtimeOnly: 0,
-          backtestOnly: 0,
-          targets: 0,
-          compared: 0,
-          errors: 0
-        };
-        rows.set(strategy, row);
-        return row;
-      };
-      for (const target of targets) {
-        const row = ensureRow(target.strategy);
-        row.targets += 1;
-        if (successfulTargetKeys.has(toTargetKey(target))) {
-          row.compared += 1;
-        }
-      }
-      for (const error of replayErrors) {
-        ensureRow(error.strategy).errors += 1;
-      }
-      return [...rows.entries()].sort(
-        ([left], [right]) => left.localeCompare(right)
-      );
-    };
+  }
+});
+
+// src/lib/runtimeParity/reportingTelegram.ts
+var TELEGRAM_DETAIL_LIMIT, SUMMARY_TIMEZONE, SUMMARY_TIMEZONE_LABEL, escapeHtml5, formatMskDateTime2, buildRuntimeParityMessage, buildRuntimeParityNoTargetsMessage;
+var init_reportingTelegram = __esm({
+  "src/lib/runtimeParity/reportingTelegram.ts"() {
+    "use strict";
+    init_classification();
+    init_reportingShared();
+    TELEGRAM_DETAIL_LIMIT = 5;
+    SUMMARY_TIMEZONE = "Europe/Moscow";
+    SUMMARY_TIMEZONE_LABEL = "MSK";
+    escapeHtml5 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    formatMskDateTime2 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+      timeZone: SUMMARY_TIMEZONE,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    }).format(new Date(timestamp));
     buildRuntimeParityMessage = ({
-      window,
-      connectorName,
-      replayEnv,
       runtimeGatesEnabled,
-      toleranceBars,
-      toleranceMs,
-      replayTargetsCount,
-      comparedTargetsCount,
-      replayErrors,
-      sourceCounts,
-      rawRuntimeEntriesCount,
-      runtimeEntriesCount,
-      runtimeDuplicateEntriesCount,
-      backtestEntriesCount,
-      matchedCount: _matchedCount,
-      runtimeOnlyCount,
-      backtestOnlyCount,
-      matchedSummary,
-      classifiedRuntimeOnly,
-      classifiedBacktestOnly,
-      runtimeSignalEvaluationsCount,
-      strategyRows,
-      runtimeGateWarningCounts
+      runtimeGateWarningCounts,
+      ...context
     }) => {
       const lines = [];
       lines.push("\u{1F9EA} <b>TradeJS runtime parity</b>");
       lines.push("");
       lines.push("\u{1F552} <b>Window</b>");
       lines.push(
-        `<b>${escapeHtml5(formatMskDateTime2(window.start))} - ${escapeHtml5(formatMskDateTime2(window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`
+        `<b>${escapeHtml5(formatMskDateTime2(context.window.start))} - ${escapeHtml5(formatMskDateTime2(context.window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`
       );
       lines.push("");
-      lines.push(`\u{1F50C} Connector: <b>${escapeHtml5(connectorName)}</b>`);
-      lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml5(replayEnv)}</b>`);
+      lines.push(`\u{1F50C} Connector: <b>${escapeHtml5(context.connectorName)}</b>`);
+      lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml5(context.replayEnv)}</b>`);
       lines.push(
-        `\u{1F3AF} Tolerance: <b>${toleranceBars} bar(s) / ${(toleranceMs / 6e4).toFixed(0)}m</b>`
+        `\u{1F3AF} Tolerance: <b>${context.toleranceBars} bar(s) / ${(context.toleranceMs / 6e4).toFixed(0)}m</b>`
       );
       lines.push("");
       lines.push("\u{1F4CC} <b>Overview</b>");
       lines.push(
-        `\u2022 Targets: <b>${replayTargetsCount}</b> / compared <b>${comparedTargetsCount}</b> / errors <b>${replayErrors.length}</b>`
+        `\u2022 Targets: <b>${context.replayTargetsCount}</b> / compared <b>${context.comparedTargetsCount}</b> / errors <b>${context.replayErrors.length}</b>`
       );
       lines.push(
-        `\u2022 Sources: <b>${escapeHtml5(formatSourceCountsSummary(sourceCounts))}</b>`
+        `\u2022 Sources: <b>${escapeHtml5(formatSourceCountsSummary(context.sourceCounts))}</b>`
       );
       lines.push("");
       lines.push("\u{1F4C8} <b>Entries</b>");
       lines.push(
-        `\u2022 Runtime: <b>${escapeHtml5(
-          formatRuntimeEntriesSummary({
-            rawRuntimeEntriesCount,
-            runtimeEntriesCount,
-            runtimeDuplicateEntriesCount
-          })
-        )}</b>`
+        `\u2022 Runtime: <b>${escapeHtml5(formatRuntimeEntriesSummary(context))}</b>`
       );
-      lines.push(`\u2022 Backtest: <b>${backtestEntriesCount}</b>`);
+      lines.push(`\u2022 Backtest: <b>${context.backtestEntriesCount}</b>`);
       lines.push(
-        `\u2022 Runtime only: <b>${runtimeOnlyCount}</b> / Backtest only: <b>${backtestOnlyCount}</b>`
+        `\u2022 Runtime only: <b>${context.runtimeOnlyCount}</b> / Backtest only: <b>${context.backtestOnlyCount}</b>`
       );
       lines.push(
-        `\u2022 Matched deltas: price avg/max=<b>${escapeHtml5(formatPercent4(matchedSummary.avgPriceDeltaPct))} / ${escapeHtml5(formatPercent4(matchedSummary.maxPriceDeltaPct))}</b>, time avg/max=<b>${escapeHtml5(formatMinutes2(matchedSummary.avgTimestampDiffMs))} / ${escapeHtml5(formatMinutes2(matchedSummary.maxTimestampDiffMs))}</b>`
+        `\u2022 Matched deltas: price avg/max=<b>${escapeHtml5(formatPercent4(context.matchedSummary.avgPriceDeltaPct))} / ${escapeHtml5(formatPercent4(context.matchedSummary.maxPriceDeltaPct))}</b>, time avg/max=<b>${escapeHtml5(formatMinutes2(context.matchedSummary.avgTimestampDiffMs))} / ${escapeHtml5(formatMinutes2(context.matchedSummary.maxTimestampDiffMs))}</b>`
       );
-      if (classifiedRuntimeOnly.length) {
+      if (context.classifiedRuntimeOnly.length) {
         lines.push(
-          `\u2022 Runtime-only classes: <code>${escapeHtml5(summarizeRuntimeOnlyClassifications(classifiedRuntimeOnly))}</code>`
+          `\u2022 Runtime-only classes: <code>${escapeHtml5(summarizeRuntimeOnlyClassifications(context.classifiedRuntimeOnly))}</code>`
         );
       }
-      if (classifiedBacktestOnly.length) {
+      if (context.classifiedBacktestOnly.length) {
         lines.push(
-          `\u2022 Backtest-only classes: <code>${escapeHtml5(summarizeBacktestOnlyClassifications(classifiedBacktestOnly))}</code>`
+          `\u2022 Backtest-only classes: <code>${escapeHtml5(summarizeBacktestOnlyClassifications(context.classifiedBacktestOnly))}</code>`
         );
       }
-      if (runtimeSignalEvaluationsCount) {
+      if (context.runtimeSignalEvaluationsCount) {
         lines.push(
-          `\u2022 Runtime evaluations: <b>${runtimeSignalEvaluationsCount}</b>`
+          `\u2022 Runtime evaluations: <b>${context.runtimeSignalEvaluationsCount}</b>`
         );
       }
-      const mismatchRows = buildMismatchSummaryRows({
-        classifiedRuntimeOnly,
-        classifiedBacktestOnly
-      });
+      const mismatchRows = buildMismatchSummaryRows(context);
       if (mismatchRows.length) {
         lines.push("");
-        lines.push(`\u{1F50E} <b>Mismatches</b>`);
+        lines.push("\u{1F50E} <b>Mismatches</b>");
         for (const item of mismatchRows.slice(0, TELEGRAM_DETAIL_LIMIT)) {
           lines.push(`\u2022 <code>${escapeHtml5(item.line)}</code>`);
         }
@@ -31094,17 +30984,17 @@ var init_runtimeParity2 = __esm({
           );
         }
       }
-      const strategyIssueRows = buildStrategyIssueRows(strategyRows);
+      const strategyIssueRows = buildStrategyIssueRows(context.strategyRows);
       if (strategyIssueRows.length) {
         lines.push("");
         lines.push("\u{1F4CA} <b>Strategy issues</b>");
         for (const line of strategyIssueRows) {
           lines.push(`\u2022 ${escapeHtml5(line.slice(2))}`);
         }
-      } else if (strategyRows.length) {
+      } else if (context.strategyRows.length) {
         lines.push("");
         lines.push(
-          `\u{1F4CA} <b>Strategies</b>: clean <b>${strategyRows.length}</b> / total <b>${strategyRows.length}</b>`
+          `\u{1F4CA} <b>Strategies</b>: clean <b>${context.strategyRows.length}</b> / total <b>${context.strategyRows.length}</b>`
         );
       }
       if (runtimeGateWarningCounts.size && !runtimeGatesEnabled) {
@@ -31118,17 +31008,17 @@ var init_runtimeParity2 = __esm({
           );
         }
       }
-      if (replayErrors.length) {
+      if (context.replayErrors.length) {
         lines.push("");
         lines.push("\u274C <b>Replay errors</b>");
-        for (const error of replayErrors.slice(0, TELEGRAM_DETAIL_LIMIT)) {
+        for (const error of context.replayErrors.slice(0, TELEGRAM_DETAIL_LIMIT)) {
           lines.push(
             `\u2022 <b>${escapeHtml5(error.strategy)}</b> ${escapeHtml5(error.symbol)}: <code>${escapeHtml5(error.message)}</code>`
           );
         }
-        if (replayErrors.length > TELEGRAM_DETAIL_LIMIT) {
+        if (context.replayErrors.length > TELEGRAM_DETAIL_LIMIT) {
           lines.push(
-            `... <b>${replayErrors.length - TELEGRAM_DETAIL_LIMIT}</b> more`
+            `... <b>${context.replayErrors.length - TELEGRAM_DETAIL_LIMIT}</b> more`
           );
         }
       }
@@ -31138,7 +31028,6 @@ var init_runtimeParity2 = __esm({
       window,
       connectorName,
       replayEnv,
-      runtimeGatesEnabled: _runtimeGatesEnabled,
       userName: userName3
     }) => [
       "\u{1F9EA} <b>TradeJS runtime parity</b>",
@@ -31151,19 +31040,278 @@ var init_runtimeParity2 = __esm({
       "",
       `\u26A0\uFE0F No replay targets found for user <b>${escapeHtml5(userName3)}</b>.`
     ].join("\n");
-    runtimeParity = async () => {
-      const window = resolveTimeWindow({
-        days: flags28.days ?? DEFAULT_LOOKBACK_DAYS,
-        startTime: flags28.startTime,
-        endTime: flags28.endTime,
-        defaultStartMs: Date.now() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3,
-        defaultEndMs: Date.now()
-      });
-      const toleranceBars = Math.max(
-        0,
-        Number.parseInt(String(flags28.toleranceBars ?? 1), 10) || 0
+  }
+});
+
+// src/lib/runtimeParity/reporting.ts
+var init_reporting = __esm({
+  "src/lib/runtimeParity/reporting.ts"() {
+    "use strict";
+    init_reportingShared();
+    init_reportingJson();
+    init_reportingTerminal();
+    init_reportingTelegram();
+  }
+});
+
+// src/scripts/runtimeParity.ts
+var runtimeParity_exports = {};
+__export(runtimeParity_exports, {
+  buildRuntimeParityMessage: () => buildRuntimeParityMessage,
+  main: () => main40,
+  runtimeParity: () => runtimeParity
+});
+var import_config11, import_node_crypto14, import_args30, import_chalk44, import_constants15, import_time9, import_logger6, import_redis17, import_cli11, import_backtest3, import_connectors14, flags28, interval3, projectRoot13, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main40;
+var init_runtimeParity2 = __esm({
+  "src/scripts/runtimeParity.ts"() {
+    "use strict";
+    import_config11 = require("dotenv/config");
+    import_node_crypto14 = require("crypto");
+    import_args30 = __toESM(require("args"));
+    import_chalk44 = __toESM(require("chalk"));
+    import_constants15 = require("@tradejs/core/constants");
+    import_time9 = require("@tradejs/core/time");
+    import_logger6 = require("@tradejs/infra/logger");
+    import_redis17 = require("@tradejs/infra/redis");
+    import_cli11 = require("@tradejs/node/cli");
+    import_backtest3 = require("@tradejs/node/backtest");
+    import_connectors14 = require("@tradejs/node/connectors");
+    init_runtimeParity();
+    init_cliArgs();
+    init_runtimeRedis();
+    init_runtimeSignalsLoader();
+    init_telegramReports();
+    init_timeWindow();
+    init_runFormatting();
+    init_marketContextPrepare();
+    init_historyPrepare();
+    init_targets();
+    init_evidence();
+    init_analysis();
+    init_reporting();
+    init_reporting();
+    init_runtimeModeConfig();
+    import_args30.default.option(["u", "user"], "Use user config", "root");
+    import_args30.default.option(
+      ["o", "connector"],
+      "Connector provider or name for parity replay (e.g. bybit, binance, coinbase, custom)",
+      "bybit"
+    );
+    import_args30.default.option(["d", "days"], "Replay window in days", 3);
+    import_args30.default.option(
+      ["b", "startTime"],
+      "Explicit replay start timestamp (ms or seconds)"
+    );
+    import_args30.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
+    import_args30.default.option(["s", "strategy"], "Only compare one strategy");
+    import_args30.default.option(
+      ["t", "tickers"],
+      "Replay comma-separated symbols for all configured strategies"
+    );
+    import_args30.default.option(
+      ["C", "cacheOnly"],
+      "Do not refresh market history before replay",
+      false
+    );
+    import_args30.default.option(
+      ["a", "toleranceBars"],
+      "Allowed entry timestamp drift in bars when matching runtime vs backtest",
+      1
+    );
+    import_args30.default.option(
+      "fullUniverse",
+      "Replay every configured strategy across the full connector universe. By default parity replays only runtime-traded and strategy-results symbols unless --tickers is provided.",
+      false
+    );
+    import_args30.default.option(
+      "runtimeGates",
+      "Force runtime AI/ML gates for all replay targets. Runtime-gated configs are replayed with gates by default.",
+      false
+    );
+    import_args30.default.option(["N", "notify"], "Send parity summary to Telegram", false);
+    import_args30.default.option(["D", "details"], "Print unmatched entry details (capped)", false);
+    process.argv = normalizeCliArgv(process.argv, {
+      "-C": "--cacheOnly",
+      "-D": "--details",
+      "-E": "--endTime",
+      "-N": "--notify",
+      "-S": "--startTime",
+      "-T": "--toleranceBars"
+    });
+    flags28 = import_args30.default.parse(process.argv);
+    interval3 = "15";
+    projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    DEFAULT_LOOKBACK_DAYS = 3;
+    DETAIL_LIMIT2 = 10;
+    DEFAULT_REPLAY_ENV = flags28.runtimeGates ? "PARITY" : "BACKTEST";
+    resolveParityConnectorName = async (value) => {
+      const connectorName = await (0, import_connectors14.resolveConnectorName)(value, projectRoot13);
+      if (connectorName) {
+        return connectorName;
+      }
+      import_logger6.logger.warn(
+        'Unknown connector "%s". Fallback to %s.',
+        String(value || "").trim() || String(value),
+        import_connectors14.DEFAULT_CONNECTOR_NAME
       );
-      const toleranceMs = toleranceBars * 15 * 60 * 1e3;
+      return import_connectors14.DEFAULT_CONNECTOR_NAME;
+    };
+    createConnector = async ({
+      userName: userName3,
+      connectorName
+    }) => {
+      const connectorFactory = await (0, import_connectors14.getConnectorCreatorByName)(
+        connectorName,
+        projectRoot13
+      );
+      if (!connectorFactory) {
+        throw new Error(`Connector "${connectorName}" is not registered`);
+      }
+      return await connectorFactory({ userName: userName3 });
+    };
+    buildReplayAiAnalyses = ({
+      runtimeTrades,
+      runtimeSignalEvaluations,
+      toleranceMs
+    }) => {
+      const snapshots = [
+        ...runtimeTrades.filter(
+          (trade) => trade.aiAnalysis && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp)
+        ).map((trade) => ({
+          strategy: trade.strategy,
+          symbol: trade.symbol,
+          direction: trade.direction,
+          timestamp: trade.entryTimestamp,
+          toleranceMs,
+          analysis: trade.aiAnalysis
+        })),
+        ...runtimeSignalEvaluations.filter(
+          (evaluation) => evaluation.aiAnalysis && evaluation.direction && typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp)
+        ).map((evaluation) => ({
+          strategy: evaluation.strategy,
+          symbol: evaluation.symbol,
+          direction: evaluation.direction,
+          timestamp: evaluation.timestamp,
+          toleranceMs,
+          analysis: evaluation.aiAnalysis
+        }))
+      ];
+      const seen = /* @__PURE__ */ new Set();
+      return snapshots.filter((snapshot) => {
+        const key = `${snapshot.strategy}:${snapshot.symbol}:${snapshot.direction}:${snapshot.timestamp}`;
+        if (seen.has(key)) {
+          return false;
+        }
+        seen.add(key);
+        return true;
+      });
+    };
+    formatReplayEnvSummary = (configs) => {
+      let backtest2 = 0;
+      let parity = 0;
+      for (const config2 of configs) {
+        if (config2.ENV === "PARITY") {
+          parity += 1;
+        } else {
+          backtest2 += 1;
+        }
+      }
+      if (parity > 0 && backtest2 > 0) {
+        return `MIXED (PARITY=${parity}, BACKTEST=${backtest2})`;
+      }
+      if (parity > 0) {
+        return "PARITY";
+      }
+      return "BACKTEST";
+    };
+    buildReplayConfig = async ({
+      userName: userName3,
+      strategy,
+      symbol,
+      replayInputsIndex,
+      toleranceMs
+    }) => {
+      const [userConfig, strategyResults] = await Promise.all([
+        (0, import_redis17.getData)(import_redis17.redisKeys.strategyConfig(userName3, strategy), {}),
+        (0, import_redis17.getData)(import_redis17.redisKeys.strategyResults(userName3, strategy), {})
+      ]);
+      const typedResults = strategyResults ?? {};
+      const symbolResult = typedResults?.[symbol];
+      const symbolConfig = symbolResult && symbolResult.config && typeof symbolResult.config === "object" ? symbolResult.config : {};
+      const replayInputs = replayInputsIndex.get(toTargetKey({ strategy, symbol }));
+      const aiReplayAnalyses = buildReplayAiAnalyses({
+        runtimeTrades: replayInputs?.runtimeTrades ?? [],
+        runtimeSignalEvaluations: replayInputs?.runtimeSignalEvaluations ?? [],
+        strategy,
+        symbol,
+        toleranceMs
+      });
+      const strategyConfig = {
+        ...userConfig,
+        ...symbolConfig
+      };
+      return buildRuntimeModeStrategyConfig({
+        strategyConfig,
+        env: resolveReplayStrategyEnv({
+          strategyConfig,
+          forceRuntimeGates: Boolean(flags28.runtimeGates)
+        }),
+        interval: interval3,
+        makeOrders: true,
+        recordRuntimeTrades: false,
+        aiReplayAnalyses
+      });
+    };
+    warmReplayHistory = async ({
+      userName: userName3,
+      connectorName,
+      targets,
+      preloadStart,
+      preloadEnd
+    }) => {
+      const connector = await createConnector({ userName: userName3, connectorName });
+      const symbols = [...new Set(targets.map((target) => target.symbol))];
+      const warmStartedAt = Date.now();
+      console.log(
+        import_chalk44.default.gray(
+          `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time9.formatUnix)(preloadStart)} -> ${(0, import_time9.formatUnix)(preloadEnd)}`
+        )
+      );
+      const btcReferences = await loadBtcReferenceConnectors({
+        connectorName,
+        marketConnector: connector,
+        userName: userName3,
+        projectRoot: projectRoot13,
+        shouldUseDedicatedReferences: true,
+        warn: (message) => import_logger6.logger.warn(message)
+      });
+      await updateMarketHistoryWithBtcReferences({
+        marketConnector: connector,
+        connectorName,
+        btcReferences,
+        interval: interval3,
+        symbols,
+        preloadStart,
+        preloadEnd,
+        log: (message) => console.log(import_chalk44.default.gray(message))
+      });
+      console.log(
+        import_chalk44.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
+      );
+    };
+    runtimeParity = async () => {
+      const window = resolveTimeWindow({
+        days: flags28.days ?? DEFAULT_LOOKBACK_DAYS,
+        startTime: flags28.startTime,
+        endTime: flags28.endTime,
+        defaultStartMs: Date.now() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3,
+        defaultEndMs: Date.now()
+      });
+      const toleranceBars = Math.max(
+        0,
+        Number.parseInt(String(flags28.toleranceBars ?? 1), 10) || 0
+      );
+      const toleranceMs = toleranceBars * 15 * 60 * 1e3;
       const connectorName = await resolveParityConnectorName(flags28.connector);
       const requestedSymbols = parseSymbolsFromCLI2(String(flags28.tickers || ""));
       const requestedSymbolSet = requestedSymbols.length ? new Set(requestedSymbols) : null;
@@ -31173,28 +31321,18 @@ var init_runtimeParity2 = __esm({
           userName: flags28.user,
           connectorName
         });
-        const [allRuntimeTrades, allRuntimeSignals, allRuntimeSignalEvaluations] = await Promise.all([
-          loadRuntimeTrades(flags28.user, {
-            startTime: window.start,
-            endTime: window.end
-          }),
-          loadRuntimeSignals(flags28.user, {
-            startTime: window.start,
-            endTime: window.end
-          }),
-          loadRuntimeSignalEvaluations(flags28.user, {
-            startTime: window.start,
-            endTime: window.end
-          })
-        ]);
-        const runtimeTrades = allRuntimeTrades.filter(
-          (trade) => trade.entryTimestamp >= window.start && trade.entryTimestamp <= window.end && (!flags28.strategy || trade.strategy === flags28.strategy) && (!requestedSymbolSet || requestedSymbolSet.has(trade.symbol))
-        );
-        const runtimeSignals = allRuntimeSignals.filter(
-          (signal) => signal.timestamp >= window.start && signal.timestamp <= window.end && (!flags28.strategy || signal.strategy === flags28.strategy) && (!requestedSymbolSet || requestedSymbolSet.has(signal.symbol))
-        );
-        const runtimeSignalEvaluations = allRuntimeSignalEvaluations.filter(
-          (evaluation) => evaluation.timestamp >= window.start && evaluation.timestamp <= window.end && (!flags28.strategy || evaluation.strategy === flags28.strategy) && (!requestedSymbolSet || requestedSymbolSet.has(evaluation.symbol))
+        const { runtimeTrades, runtimeSignals, runtimeSignalEvaluations } = await loadRuntimeParityEvidence(
+          {
+            userName: flags28.user,
+            window,
+            strategy: flags28.strategy,
+            symbols: requestedSymbolSet
+          },
+          {
+            loadRuntimeTrades,
+            loadRuntimeSignals,
+            loadRuntimeSignalEvaluations
+          }
         );
         const connectorSymbols = requestedSymbols.length ? requestedSymbols : await (0, import_cli11.getTickers)(parityConnector);
         const replayInputsIndex = buildReplayInputsIndex({
@@ -31211,8 +31349,8 @@ var init_runtimeParity2 = __esm({
         });
         if (!replayTargets.length) {
           console.log(
-            import_chalk43.default.yellow(
-              `No replay targets found for ${flags28.user} in ${(0, import_time7.formatUnix)(window.start)} -> ${(0, import_time7.formatUnix)(window.end)}.`
+            import_chalk44.default.yellow(
+              `No replay targets found for ${flags28.user} in ${(0, import_time9.formatUnix)(window.start)} -> ${(0, import_time9.formatUnix)(window.end)}.`
             )
           );
           if (flags28.notify) {
@@ -31230,7 +31368,7 @@ var init_runtimeParity2 = __esm({
           return;
         }
         const sourceCounts = countReplayTargetSources(replayTargets);
-        const preloadStart = (0, import_time7.getBacktestPreloadStart)(
+        const preloadStart = (0, import_time9.getBacktestPreloadStart)(
           window.start,
           import_constants15.BACKTEST_PRELOAD_DAYS
         );
@@ -31239,7 +31377,7 @@ var init_runtimeParity2 = __esm({
           replayTargets.map((target) => target.symbol)
         ).size;
         console.log(
-          import_chalk43.default.gray(
+          import_chalk44.default.gray(
             `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags28.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
           )
         );
@@ -31274,7 +31412,7 @@ var init_runtimeParity2 = __esm({
           aiEnabled: hasParityAiTargets,
           mlEnabled: hasParityMlTargets,
           strategyNames: replayTargets.map((target) => target.strategy),
-          log: (message) => console.log(import_chalk43.default.gray(message))
+          log: (message) => console.log(import_chalk44.default.gray(message))
         });
         if (!flags28.cacheOnly) {
           await warmReplayHistory({
@@ -31342,139 +31480,61 @@ var init_runtimeParity2 = __esm({
           }
           if (progressPosition === 1 || progressPosition === replayTargets.length || progressPosition % 25 === 0) {
             console.log(
-              import_chalk43.default.gray(
+              import_chalk44.default.gray(
                 `Replay progress: ${progressPosition}/${replayTargets.length}, ok=${successfulTargetKeys.size}, errors=${replayErrors.length}, current=${target.strategy} ${target.symbol}, elapsed=${formatDuration(replayStartedAt)}`
               )
             );
           }
         }
-        const comparableRuntimeTrades = runtimeTrades.filter(
-          (trade) => successfulTargetKeys.has(toTargetKey(trade))
-        );
-        const rawRuntimeEntries = extractRuntimeParityEntries(
-          comparableRuntimeTrades
-        );
-        const runtimeDedupe = dedupeRuntimeParityEntries(rawRuntimeEntries);
-        const runtimeEntries = runtimeDedupe.entries;
-        const comparison = compareTradeParityEntries({
+        const {
+          rawRuntimeEntries,
+          runtimeDedupe,
           runtimeEntries,
-          backtestEntries,
-          toleranceMs
-        });
-        const classifiedBacktestOnly = classifyBacktestOnlyEntries({
-          entries: comparison.backtestOnly,
+          comparison,
+          classifiedBacktestOnly,
+          classifiedRuntimeOnly,
+          matchedSummary: summary,
+          strategyRows
+        } = analyzeRuntimeParity({
+          runtimeTrades,
           runtimeSignals,
           runtimeSignalEvaluations,
-          toleranceMs
-        });
-        const classifiedRuntimeOnly = classifyRuntimeOnlyEntries({
-          entries: comparison.runtimeOnly,
-          replaySignalEvaluations,
           backtestEntries,
+          replaySignalEvaluations,
+          replayTargets,
+          successfulTargetKeys,
+          replayErrors,
           toleranceMs
         });
-        const summary = summarizeMatchedParity(comparison.matched);
-        console.log(import_chalk43.default.cyan("TradeJS runtime parity"));
-        console.log(
-          `Window: ${(0, import_time7.formatUnix)(window.start)} -> ${(0, import_time7.formatUnix)(window.end)} (${window.source})`
-        );
-        console.log(`Connector: ${connectorName}`);
-        console.log(
-          `Replay env: ${replayEnvSummary}${flags28.runtimeGates || replayEnvSummary.includes("PARITY") ? " (runtime AI/ML gates enabled)" : " (core/backtest gates only)"}`
-        );
-        console.log(
-          `Tolerance: ${toleranceBars} bar(s) / ${(toleranceMs / 6e4).toFixed(0)}m`
-        );
-        console.log(
-          `Summary: targets=${replayTargets.length}, compared=${successfulTargetKeys.size}, errors=${replayErrors.length}, runtime=${runtimeEntries.length}, backtest=${backtestEntries.length}, runtimeOnly=${comparison.runtimeOnly.length}, backtestOnly=${comparison.backtestOnly.length}, evaluations=${runtimeSignalEvaluations.length}`
-        );
-        console.log(`Sources: ${formatSourceCountsSummary(sourceCounts)}`);
-        console.log(
-          `Runtime entries: ${formatRuntimeEntriesSummary({
+        writeRuntimeParityTerminalReport(
+          buildRuntimeParityTerminalReport({
+            window,
+            connectorName,
+            replayEnv: replayEnvSummary,
+            runtimeGatesEnabled: Boolean(flags28.runtimeGates) || replayEnvSummary.includes("PARITY"),
+            runtimeGatesRequested: Boolean(flags28.runtimeGates),
+            toleranceBars,
+            toleranceMs,
+            replayTargetsCount: replayTargets.length,
+            comparedTargetsCount: successfulTargetKeys.size,
+            replayErrors,
+            sourceCounts,
             rawRuntimeEntriesCount: rawRuntimeEntries.length,
             runtimeEntriesCount: runtimeEntries.length,
-            runtimeDuplicateEntriesCount: runtimeDedupe.duplicateEntries.length
-          })}`
-        );
-        console.log(
-          `Matched deltas: price avg/max=${formatPercent4(summary.avgPriceDeltaPct)} / ${formatPercent4(summary.maxPriceDeltaPct)}, time avg/max=${formatMinutes2(summary.avgTimestampDiffMs)} / ${formatMinutes2(summary.maxTimestampDiffMs)}`
+            runtimeDuplicateGroupsCount: runtimeDedupe.duplicateGroups.length,
+            runtimeDuplicateEntriesCount: runtimeDedupe.duplicateEntries.length,
+            backtestEntriesCount: backtestEntries.length,
+            runtimeOnlyCount: comparison.runtimeOnly.length,
+            backtestOnlyCount: comparison.backtestOnly.length,
+            matchedSummary: summary,
+            classifiedRuntimeOnly,
+            classifiedBacktestOnly,
+            runtimeSignalEvaluationsCount: runtimeSignalEvaluations.length,
+            strategyRows,
+            runtimeGateWarningCounts,
+            detailLimit: DETAIL_LIMIT2
+          })
         );
-        if (runtimeDedupe.duplicateGroups.length) {
-          console.log(
-            `Runtime duplicate groups: ${runtimeDedupe.duplicateGroups.length}, duplicate entries: ${runtimeDedupe.duplicateEntries.length}`
-          );
-        }
-        if (classifiedRuntimeOnly.length) {
-          console.log(
-            `Runtime only classifications: ${summarizeRuntimeOnlyClassifications(classifiedRuntimeOnly)}`
-          );
-        }
-        if (classifiedBacktestOnly.length) {
-          console.log(
-            `Backtest only classifications: ${summarizeBacktestOnlyClassifications(classifiedBacktestOnly)}`
-          );
-        }
-        if (runtimeSignalEvaluations.length) {
-          console.log(`Runtime evaluations: ${runtimeSignalEvaluations.length}`);
-        }
-        const strategyRows = summarizeByStrategy({
-          targets: replayTargets,
-          successfulTargetKeys,
-          replayErrors,
-          runtimeEntries,
-          runtimeDuplicateEntries: runtimeDedupe.duplicateEntries,
-          backtestEntries,
-          matchedEntries: comparison.matched,
-          runtimeOnlyEntries: comparison.runtimeOnly,
-          backtestOnlyEntries: comparison.backtestOnly
-        });
-        const mismatchRows = buildMismatchSummaryRows({
-          classifiedRuntimeOnly,
-          classifiedBacktestOnly
-        });
-        const strategyIssueRows = buildStrategyIssueRows(strategyRows);
-        if (mismatchRows.length) {
-          console.log("");
-          console.log(import_chalk43.default.yellow("Signal mismatches"));
-          for (const item of mismatchRows.slice(0, DETAIL_LIMIT)) {
-            console.log(`- ${item.line}`);
-          }
-          if (mismatchRows.length > DETAIL_LIMIT) {
-            console.log(`- ... ${mismatchRows.length - DETAIL_LIMIT} more`);
-          }
-        }
-        console.log("");
-        if (strategyIssueRows.length) {
-          console.log(import_chalk43.default.cyan("Strategy issues"));
-          for (const line of strategyIssueRows) {
-            console.log(line);
-          }
-        } else if (strategyRows.length) {
-          console.log(
-            `Strategies: clean ${strategyRows.length}/${strategyRows.length}`
-          );
-        }
-        if (runtimeGateWarningCounts.size && !flags28.runtimeGates) {
-          console.log("");
-          console.log(import_chalk43.default.yellow("Warnings"));
-          for (const [strategy, count] of [
-            ...runtimeGateWarningCounts.entries()
-          ].sort(([left], [right]) => left.localeCompare(right))) {
-            console.log(
-              `- ${strategy} uses AI/ML runtime gates on ${count} replay target(s); BACKTEST replay covers core execution, not live gating.`
-            );
-          }
-        }
-        if (replayErrors.length) {
-          console.log("");
-          console.log(import_chalk43.default.red("Replay errors"));
-          for (const error of replayErrors.slice(0, DETAIL_LIMIT)) {
-            console.log(`- ${error.strategy} ${error.symbol}: ${error.message}`);
-          }
-          if (replayErrors.length > DETAIL_LIMIT) {
-            console.log(`- ... ${replayErrors.length - DETAIL_LIMIT} more`);
-          }
-        }
         if (flags28.details) {
           printRuntimeDuplicateDetails(runtimeDedupe.duplicateGroups);
           printClassifiedRuntimeOnlyDetails(classifiedRuntimeOnly);
@@ -31619,11 +31679,11 @@ var init_runtimeStrategies = __esm({
 });
 
 // src/lib/signals/skipStats.ts
-var import_chalk44, import_logger7, createStrategySkipStats, recordStrategyReason, logStrategySkipStats;
+var import_chalk45, import_logger7, createStrategySkipStats, recordStrategyReason, logStrategySkipStats;
 var init_skipStats = __esm({
   "src/lib/signals/skipStats.ts"() {
     "use strict";
-    import_chalk44 = __toESM(require("chalk"));
+    import_chalk45 = __toESM(require("chalk"));
     import_logger7 = require("@tradejs/infra/logger");
     init_runtimeSignalsStorage();
     createStrategySkipStats = (runtimeStrategies) => new Map(
@@ -31649,7 +31709,7 @@ var init_skipStats = __esm({
       );
     };
     logStrategySkipStats = (runtimeStrategies, strategyStats) => {
-      import_logger7.logger.info(import_chalk44.default.yellow("skip stats:"));
+      import_logger7.logger.info(import_chalk45.default.yellow("skip stats:"));
       for (const { strategyName } of runtimeStrategies) {
         const stats = strategyStats.get(strategyName);
         if (!stats) {
@@ -32594,18 +32654,18 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies11, import_constants16, import_time8, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
+var import_progress11, import_chalk46, import_connectors16, import_cli12, import_async5, import_strategies11, import_constants16, import_time10, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
     import_progress11 = __toESM(require("progress"));
-    import_chalk45 = __toESM(require("chalk"));
+    import_chalk46 = __toESM(require("chalk"));
     import_connectors16 = require("@tradejs/node/connectors");
     import_cli12 = require("@tradejs/node/cli");
     import_async5 = require("@tradejs/core/async");
     import_strategies11 = require("@tradejs/core/strategies");
     import_constants16 = require("@tradejs/core/constants");
-    import_time8 = require("@tradejs/core/time");
+    import_time10 = require("@tradejs/core/time");
     import_logger10 = require("@tradejs/infra/logger");
     import_runtimeHeartbeats = require("@tradejs/infra/runtimeHeartbeats");
     import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
@@ -32666,7 +32726,7 @@ var init_runner = __esm({
       const timeOperation3 = (label, operation) => timeOperation(
         label,
         operation,
-        (message) => import_logger10.logger.info(import_chalk45.default.gray(message))
+        (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
       );
       const formatSlowSignalsWarning = (params) => [
         "<b>Slow yarn signals run</b>",
@@ -32781,7 +32841,7 @@ var init_runner = __esm({
           const selectedTickers = selection?.tickers ? [.../* @__PURE__ */ new Set([...selection.tickers, ...selectedActiveSymbols])] : void 0;
           if (selectedActiveSymbols.length) {
             import_logger10.logger.info(
-              import_chalk45.default.gray(
+              import_chalk46.default.gray(
                 `strategy selection retained active symbols: ${selectedActiveSymbols.join(", ")}`
               )
             );
@@ -32811,13 +32871,13 @@ var init_runner = __esm({
             instruments.map((instrument) => [instrument.symbol, instrument])
           );
           if (config2.showTickersList) {
-            console.log(import_chalk45.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+            console.log(import_chalk46.default.gray(JSON.stringify(tickers.sort(), null, 2)));
             return;
           }
           const projectConfig = await (0, import_cli12.loadTradejsConfig)(projectRoot15);
           projectHooks = projectConfig.hooks;
-          const currentTimestamp = (0, import_time8.getTimestamp)();
-          const preloadStart = (0, import_time8.getTimestamp)(import_constants16.SIGNALS_CLI_PRELOAD_DAYS);
+          const currentTimestamp = (0, import_time10.getTimestamp)();
+          const preloadStart = (0, import_time10.getTimestamp)(import_constants16.SIGNALS_CLI_PRELOAD_DAYS);
           if (!config2.cacheOnly && session.klineFeed) {
             const expectedSymbols = universe === "crypto" ? [.../* @__PURE__ */ new Set([...tickers, "BTCUSDT", "ETHUSDT"])] : tickers;
             session.klineFeed.setSubscriptions(expectedSymbols);
@@ -32832,7 +32892,7 @@ var init_runner = __esm({
             );
             await session.klineFeed.flush();
             import_logger10.logger.info(
-              import_chalk45.default.gray(
+              import_chalk46.default.gray(
                 `websocket candles: ready=${expectedSymbols.length - missingSymbols.length}/${expectedSymbols.length} missing=${missingSymbols.length}`
               )
             );
@@ -32843,7 +32903,7 @@ var init_runner = __esm({
               symbols: missingSymbols,
               preloadDays: import_constants16.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger10.logger.info(import_chalk45.default.gray(message))
+              log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
             });
             await updateBtcReferenceHistory({
               marketConnector,
@@ -32851,7 +32911,7 @@ var init_runner = __esm({
               interval: interval5,
               preloadDays: import_constants16.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger10.logger.info(import_chalk45.default.gray(message))
+              log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
             });
           } else if (!config2.cacheOnly) {
             await updateMarketHistoryWithBtcReferences({
@@ -32862,7 +32922,7 @@ var init_runner = __esm({
               symbols: tickers,
               preloadDays: import_constants16.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger10.logger.info(import_chalk45.default.gray(message))
+              log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
             });
           }
           await prepareMarketContextForRun({
@@ -32876,7 +32936,7 @@ var init_runner = __esm({
             endMs: currentTimestamp,
             preloadStartMs: preloadStart,
             cacheOnly: config2.cacheOnly,
-            log: (message) => import_logger10.logger.info(import_chalk45.default.gray(message))
+            log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
           });
           if (config2.updateOnly) {
             return;
@@ -32971,7 +33031,7 @@ var init_runner = __esm({
             )
           );
           import_logger10.logger.info(
-            import_chalk45.default.yellow(
+            import_chalk46.default.yellow(
               `loaded strategies (user=${config2.userName}): ${runtimeStrategies.map(formatConfiguredStrategyIdentity).join(", ")}`
             )
           );
@@ -33007,9 +33067,9 @@ var init_runner = __esm({
               width: 30
             }
           );
-          import_logger10.logger.info(import_chalk45.default.yellow(`tickers: ${tickers.length}`));
+          import_logger10.logger.info(import_chalk46.default.yellow(`tickers: ${tickers.length}`));
           const signalsParallel = resolvePositiveInteger2(config2.parallel, 4);
-          import_logger10.logger.info(import_chalk45.default.yellow(`signal workers: ${signalsParallel}`));
+          import_logger10.logger.info(import_chalk46.default.yellow(`signal workers: ${signalsParallel}`));
           const evaluateTicker = createSignalsTickerEvaluator({
             userName: config2.userName,
             makeOrders: config2.makeOrders,
@@ -33048,8 +33108,8 @@ var init_runner = __esm({
                 signals3.push(...strategySignals);
               }
               bar.tick(1, {
-                found: import_chalk45.default.cyan(signals3.length),
-                symbol: import_chalk45.default.gray(symbol)
+                found: import_chalk46.default.cyan(signals3.length),
+                symbol: import_chalk46.default.gray(symbol)
               });
             });
           });
@@ -33153,7 +33213,7 @@ var init_runner = __esm({
             }
           }
           import_logger10.logger.info(
-            import_chalk45.default.yellow(
+            import_chalk46.default.yellow(
               `signals ${status} in ${formatDuration3(durationMs)} (found=${signals3.length})`
             )
           );
@@ -34148,91 +34208,13 @@ var init_portfolioReplayConnector = __esm({
   }
 });
 
-// src/lib/replay/historicalSignalsReplay.ts
-var import_chalk46, import_progress12, import_backtest4, import_strategies12, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies13, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, strategyIncludesSymbol, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
-var init_historicalSignalsReplay = __esm({
-  "src/lib/replay/historicalSignalsReplay.ts"() {
+// src/lib/replay/historicalSignalsReplayPreparation.ts
+var buildPreparedData, strategyIncludesSymbol, buildSymbolSharedReplayKey, prepareHistoricalReplay;
+var init_historicalSignalsReplayPreparation = __esm({
+  "src/lib/replay/historicalSignalsReplayPreparation.ts"() {
     "use strict";
-    import_chalk46 = __toESM(require("chalk"));
-    import_progress12 = __toESM(require("progress"));
-    import_backtest4 = require("@tradejs/core/backtest");
-    import_strategies12 = require("@tradejs/core/strategies");
-    import_time9 = require("@tradejs/core/time");
-    import_logger11 = require("@tradejs/infra/logger");
-    import_redis19 = require("@tradejs/infra/redis");
-    import_connectors17 = require("@tradejs/node/connectors");
-    import_cli13 = require("@tradejs/node/cli");
-    import_strategies13 = require("@tradejs/node/strategies");
-    import_runtimeStrategies8 = require("@tradejs/node/runtimeStrategies");
-    init_cliConfig2();
     init_support();
-    init_portfolioReplayConnector();
     init_windows();
-    init_hooks();
-    init_runtimeLineage();
-    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_strategies13.getStrategyCreator)(
-            strategyName,
-            replayProjectRoot
-          );
-          if (!strategyCreator) {
-            throw new Error(`Unknown strategy: ${strategyName}`);
-          }
-          const installed = await (0, import_runtimeStrategies8.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_redis19.getData)(
-            import_redis19.redisKeys.strategyResults(replayUserName, strategyName),
-            {}
-          );
-          return {
-            strategyName,
-            strategyRevision,
-            deploymentCompositionId,
-            strategyPackage,
-            strategyPackageVersion,
-            strategyDependencyVersions,
-            runtimePackageVersion,
-            strategyCreator,
-            strategyConfig,
-            strategyResults,
-            ...selection ? { selection } : {}
-          };
-        })
-      );
-      return strategies;
-    };
-    loadReferenceConnector = async (connectorName) => {
-      const connectorFactory = await (0, import_connectors17.getConnectorCreatorByName)(
-        connectorName,
-        replayProjectRoot
-      );
-      if (!connectorFactory) {
-        throw new Error(`Connector "${connectorName}" is not registered`);
-      }
-      return await connectorFactory({
-        userName: replayUserName
-      });
-    };
     buildPreparedData = ({
       data,
       btcData,
@@ -34281,25 +34263,6 @@ var init_historicalSignalsReplay = __esm({
         btcCoinbasePrevData
       };
     };
-    buildAfterSignalsContext = ({
-      connector,
-      connectorName,
-      tickers,
-      runtimeStrategies,
-      interval: interval4
-    }) => ({
-      connector,
-      connectorName,
-      userName: replayUserName,
-      interval: interval4,
-      tickers: [...tickers],
-      runtimeStrategies: runtimeStrategies.map(
-        ({ strategyName, strategyConfig }) => ({
-          strategyName,
-          strategyConfig
-        })
-      )
-    });
     strategyIncludesSymbol = (strategy, symbol) => {
       const tickers = strategy.selection?.tickers;
       if (!tickers) return true;
@@ -34309,73 +34272,28 @@ var init_historicalSignalsReplay = __esm({
       );
     };
     buildSymbolSharedReplayKey = ({
+      userName: userName3,
       connectorName,
       interval: interval4,
       symbol,
       start,
       end
-    }) => ["replay", replayUserName, connectorName, symbol, interval4, start, end].join(
-      ":"
-    );
-    runHistoricalSignalsReplay = async ({
-      preparedRun,
-      interval: interval4,
-      runtimeStrategies
-    }) => {
-      const startedAt = Date.now();
-      const signals2 = [];
-      const runtimeLineages = [];
-      const projectConfig = await (0, import_cli13.loadTradejsConfig)(replayProjectRoot);
-      const projectHooks = projectConfig.hooks;
-      const loadedStrategies = await loadRuntimeStrategies(runtimeStrategies);
-      const replayConnector = createPortfolioReplayConnector(
-        preparedRun.marketConnector
-      );
-      const connectorName = String(
-        preparedRun.marketConnector?.name || import_connectors17.DEFAULT_CONNECTOR_NAME
-      ).trim() || import_connectors17.DEFAULT_CONNECTOR_NAME;
-      const binanceConnector = connectorName.toLowerCase() === import_connectors17.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Binance") : preparedRun.marketConnector;
-      const coinbaseConnector = connectorName.toLowerCase() === import_connectors17.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: interval4
-        }),
-        coinbaseConnector.kline({
-          symbol: "BTCUSDT",
-          start: preparedRun.preloadStart,
-          end: preparedRun.window.end,
-          cacheOnly: true,
-          interval: interval4
-        })
-      ]);
-      const btcMarketData = await preparedRun.marketConnector.kline({
-        symbol: "BTCUSDT",
-        start: preparedRun.preloadStart,
-        end: preparedRun.window.end,
-        cacheOnly: true,
-        interval: interval4
-      });
-      const ethMarketData = await preparedRun.marketConnector.kline({
-        symbol: "ETHUSDT",
-        start: preparedRun.preloadStart,
-        end: preparedRun.window.end,
-        cacheOnly: true,
-        interval: interval4
-      });
+    }) => ["replay", userName3, connectorName, symbol, interval4, start, end].join(":");
+    prepareHistoricalReplay = async (context, adapters) => {
+      const {
+        userName: userName3,
+        projectRoot: projectRoot15,
+        preparedRun,
+        interval: interval4,
+        connectorName,
+        replayConnector,
+        strategies,
+        references
+      } = context;
       const cycleSymbolsByTimestamp = /* @__PURE__ */ new Map();
       const sharedReplayKeyPrefixes = [];
+      const runtimeLineages = [];
       let skippedSymbols = 0;
-      const prepareBar = new import_progress12.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,
@@ -34386,22 +34304,23 @@ var init_historicalSignalsReplay = __esm({
         });
         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_chalk46.default.yellow(skippedSymbols),
-            symbol: import_chalk46.default.gray(symbol)
+          adapters.progress.tick({
+            skipped: adapters.display.skipped(skippedSymbols),
+            symbol: adapters.display.symbol(symbol)
           });
           continue;
         }
         const sharedIndicatorsReplayKey = buildSymbolSharedReplayKey({
+          userName: userName3,
           connectorName,
           interval: interval4,
           symbol,
@@ -34410,66 +34329,61 @@ var init_historicalSignalsReplay = __esm({
         });
         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: projectRoot15,
+              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(interval4),
+                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: userName3,
+                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: interval4
-                  }),
-                  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: interval4
+                }),
+                symbol,
+                data: preparedData.prevData,
+                btcData: preparedData.btcPrevData,
+                ethData: preparedData.ethPrevData,
+                btcBinanceData: preparedData.btcBinancePrevData,
+                btcCoinbaseData: preparedData.btcCoinbasePrevData,
+                connector: replayConnector,
+                sharedIndicatorsReplayKey
+              })
+            };
+          })
         );
         const symbolRuntime = {
           symbol,
@@ -34479,9 +34393,9 @@ var init_historicalSignalsReplay = __esm({
           currentIndex: 0,
           strategies: strategiesForSymbol
         };
-        prepareBar.tick(1, {
-          skipped: import_chalk46.default.yellow(skippedSymbols),
-          symbol: import_chalk46.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) ?? [];
@@ -34489,60 +34403,72 @@ var init_historicalSignalsReplay = __esm({
           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: interval4
-      });
-      let abortedCycles = 0;
-      const cycleBar = new import_progress12.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, advanceAbortedCycle, executeHistoricalReplay;
+var init_historicalSignalsReplayExecution = __esm({
+  "src/lib/replay/historicalSignalsReplayExecution.ts"() {
+    "use strict";
+    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;
+    };
+    advanceAbortedCycle = (cycleSymbols, timestamp) => {
+      for (const symbolRuntime of cycleSymbols ?? []) {
+        const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
+        if (candle?.timestamp === timestamp) {
+          symbolRuntime.currentIndex += 1;
+        }
+      }
+    };
+    executeHistoricalReplay = async (context, adapters) => {
+      const signals2 = [];
+      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_chalk46.default.cyan(signals2.length),
-              aborted: import_chalk46.default.yellow(abortedCycles),
-              ts: import_chalk46.default.gray((0, import_time9.formatUnix)(timestamp))
+            advanceAbortedCycle(cycleSymbols, timestamp);
+            adapters.progress.tick({
+              signals: adapters.display.signals(signals2.length),
+              aborted: adapters.display.aborted(abortedCycles),
+              ts: adapters.display.timestamp(timestamp)
             });
             continue;
           }
@@ -34562,81 +34488,323 @@ var init_historicalSignalsReplay = __esm({
               );
               if (result && typeof result !== "string") {
                 result.runtimeLineage = strategyRuntime.runtimeLineage;
-                await (0, import_strategies13.enrichSignalWithBinanceMarketContext)({
-                  signal: result,
-                  env: "PARITY"
-                });
+                await adapters.enrichSignal(result);
                 cycleSignals.push(result);
                 signals2.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_chalk46.default.cyan(signals2.length),
-            aborted: import_chalk46.default.yellow(abortedCycles),
-            ts: import_chalk46.default.gray((0, import_time9.formatUnix)(timestamp))
+          adapters.progress.tick({
+            signals: adapters.display.signals(signals2.length),
+            aborted: adapters.display.aborted(abortedCycles),
+            ts: adapters.display.timestamp(timestamp)
           });
         }
       } finally {
-        for (const keyPrefix of sharedReplayKeyPrefixes) {
-          (0, import_strategies12.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-          (0, import_strategies12.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_backtest4.calculateStatsFull)(positionLog) : {
-              orders: 0,
-              wins: 0,
-              losses: 0,
-              netProfit: 0,
-              amount: 0
-            }
-          };
-        }
-      );
-      import_logger11.logger.info(
-        import_chalk46.default.gray(
-          `signals replay historical cycles: ${orderedTimestamps.length} (aborted=${abortedCycles}) done in ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`
-        )
-      );
-      return {
-        strategies,
-        signals: signals2,
-        orderLog: artifacts.orderLog,
-        positionLog: artifacts.positionLog,
-        cycleCount: orderedTimestamps.length,
-        abortedCycles,
-        runtimeLineages
-      };
+      return { signals: signals2, abortedCycles };
     };
   }
 });
 
-// src/lib/replay/chartSnapshot.ts
-var formatPercent5, formatSigned2, toSimpleOrderLog, toReplayChartOrders, buildReplayChartSnapshot;
-var init_chartSnapshot = __esm({
-  "src/lib/replay/chartSnapshot.ts"() {
+// src/lib/replay/historicalSignalsReplayResults.ts
+var import_backtest4, emptyStat, collectHistoricalReplayResult;
+var init_historicalSignalsReplayResults = __esm({
+  "src/lib/replay/historicalSignalsReplayResults.ts"() {
     "use strict";
-    formatPercent5 = (value) => typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(1)}%` : "n/a";
-    formatSigned2 = (value) => typeof value === "number" && Number.isFinite(value) ? `${value >= 0 ? "+" : ""}${value.toFixed(2)}` : "n/a";
-    toSimpleOrderLog = (orderLog) => orderLog.map((entry) => [entry.timestamp, entry.amount]);
-    toReplayChartOrders = (orderLog) => orderLog.map((entry, index) => {
+    import_backtest4 = require("@tradejs/core/backtest");
+    emptyStat = () => ({
+      orders: 0,
+      wins: 0,
+      losses: 0,
+      netProfit: 0,
+      amount: 0
+    });
+    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_backtest4.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 import_chalk47, import_progress12, import_strategies12, import_time11, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies13, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildAfterSignalsContext, getConnectorName, runHistoricalSignalsReplay;
+var init_historicalSignalsReplay = __esm({
+  "src/lib/replay/historicalSignalsReplay.ts"() {
+    "use strict";
+    import_chalk47 = __toESM(require("chalk"));
+    import_progress12 = __toESM(require("progress"));
+    import_strategies12 = require("@tradejs/core/strategies");
+    import_time11 = require("@tradejs/core/time");
+    import_logger11 = require("@tradejs/infra/logger");
+    import_redis19 = require("@tradejs/infra/redis");
+    import_connectors17 = require("@tradejs/node/connectors");
+    import_cli13 = require("@tradejs/node/cli");
+    import_strategies13 = require("@tradejs/node/strategies");
+    import_runtimeStrategies8 = require("@tradejs/node/runtimeStrategies");
+    init_cliConfig2();
+    init_portfolioReplayConnector();
+    init_hooks();
+    init_runtimeLineage();
+    init_historicalSignalsReplayPreparation();
+    init_historicalSignalsReplayExecution();
+    init_historicalSignalsReplayResults();
+    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_strategies13.getStrategyCreator)(
+            strategyName,
+            replayProjectRoot
+          );
+          if (!strategyCreator) {
+            throw new Error(`Unknown strategy: ${strategyName}`);
+          }
+          const installed = await (0, import_runtimeStrategies8.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_redis19.getData)(
+            import_redis19.redisKeys.strategyResults(replayUserName, strategyName),
+            {}
+          );
+          return {
+            strategyName,
+            strategyRevision,
+            deploymentCompositionId,
+            strategyPackage,
+            strategyPackageVersion,
+            strategyDependencyVersions,
+            runtimePackageVersion,
+            strategyCreator,
+            strategyConfig,
+            strategyResults,
+            ...selection ? { selection } : {}
+          };
+        })
+      );
+      return strategies;
+    };
+    loadReferenceConnector = async (connectorName) => {
+      const connectorFactory = await (0, import_connectors17.getConnectorCreatorByName)(
+        connectorName,
+        replayProjectRoot
+      );
+      if (!connectorFactory) {
+        throw new Error(`Connector "${connectorName}" is not registered`);
+      }
+      return await connectorFactory({
+        userName: replayUserName
+      });
+    };
+    buildAfterSignalsContext = ({
+      connector,
+      connectorName,
+      tickers,
+      runtimeStrategies,
+      interval: interval4
+    }) => ({
+      connector,
+      connectorName,
+      userName: replayUserName,
+      interval: interval4,
+      tickers: [...tickers],
+      runtimeStrategies: runtimeStrategies.map(
+        ({ strategyName, strategyConfig }) => ({
+          strategyName,
+          strategyConfig
+        })
+      )
+    });
+    getConnectorName = (connector) => {
+      const name = "name" in connector ? connector.name : void 0;
+      return String(name || import_connectors17.DEFAULT_CONNECTOR_NAME).trim() || import_connectors17.DEFAULT_CONNECTOR_NAME;
+    };
+    runHistoricalSignalsReplay = async ({
+      preparedRun,
+      interval: interval4,
+      runtimeStrategies
+    }) => {
+      const startedAt = Date.now();
+      const projectConfig = await (0, import_cli13.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_connectors17.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Binance") : preparedRun.marketConnector;
+      const coinbaseConnector = connectorName.toLowerCase() === import_connectors17.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: interval4
+        }),
+        coinbaseConnector.kline({
+          symbol: "BTCUSDT",
+          start: preparedRun.preloadStart,
+          end: preparedRun.window.end,
+          cacheOnly: true,
+          interval: interval4
+        })
+      ]);
+      const btcMarketData = await preparedRun.marketConnector.kline({
+        symbol: "BTCUSDT",
+        start: preparedRun.preloadStart,
+        end: preparedRun.window.end,
+        cacheOnly: true,
+        interval: interval4
+      });
+      const ethMarketData = await preparedRun.marketConnector.kline({
+        symbol: "ETHUSDT",
+        start: preparedRun.preloadStart,
+        end: preparedRun.window.end,
+        cacheOnly: true,
+        interval: interval4
+      });
+      const prepareBar = new import_progress12.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: interval4,
+          connectorName,
+          replayConnector,
+          strategies: loadedStrategies,
+          references: {
+            btcMarketData,
+            ethMarketData,
+            btcBinanceData,
+            btcCoinbaseData
+          }
+        },
+        {
+          progress: {
+            tick: (tokens) => prepareBar.tick(1, tokens)
+          },
+          display: {
+            skipped: (value) => import_chalk47.default.yellow(value),
+            symbol: (value) => import_chalk47.default.gray(value)
+          },
+          buildLineage: buildRuntimeLineage
+        }
+      );
+      const hookContext = buildAfterSignalsContext({
+        connector: replayConnector,
+        connectorName: preparedRun.connectorName,
+        tickers: preparedRun.tickers,
+        runtimeStrategies: loadedStrategies,
+        interval: interval4
+      });
+      const cycleBar = new import_progress12.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_chalk47.default.cyan(value),
+            aborted: (value) => import_chalk47.default.yellow(value),
+            timestamp: (value) => import_chalk47.default.gray((0, import_time11.formatUnix)(value))
+          },
+          invokeBeforeSignals: invokeBeforeSignalsHooks,
+          invokeAfterSignals: invokeAfterSignalsHooks,
+          enrichSignal: (signal) => (0, import_strategies13.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" }),
+          releaseIndicatorsCache: import_strategies12.releaseStrategyIndicatorsReplayCache,
+          releaseReplayCache: import_strategies12.releaseStrategyReplayCache
+        }
+      );
+      const artifacts = replayConnector.getReplayArtifacts();
+      import_logger11.logger.info(
+        import_chalk47.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 formatPercent5, formatSigned2, toSimpleOrderLog, toReplayChartOrders, buildReplayChartSnapshot;
+var init_chartSnapshot = __esm({
+  "src/lib/replay/chartSnapshot.ts"() {
+    "use strict";
+    formatPercent5 = (value) => typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(1)}%` : "n/a";
+    formatSigned2 = (value) => typeof value === "number" && Number.isFinite(value) ? `${value >= 0 ? "+" : ""}${value.toFixed(2)}` : "n/a";
+    toSimpleOrderLog = (orderLog) => orderLog.map((entry) => [entry.timestamp, entry.amount]);
+    toReplayChartOrders = (orderLog) => orderLog.map((entry, index) => {
       const isOpenOrder = entry.type.startsWith("OPEN");
       const equityBefore = orderLog[index - 1]?.amount ?? (Number.isFinite(entry.amount) && Number.isFinite(entry.profit) ? entry.amount - entry.profit : null);
       return {
@@ -34725,11 +34893,11 @@ var init_chartSnapshot = __esm({
 });
 
 // src/lib/replay/resultsReporting.ts
-var import_chalk47, saveAndPrintReplayResultsByStrategy;
+var import_chalk48, saveAndPrintReplayResultsByStrategy;
 var init_resultsReporting = __esm({
   "src/lib/replay/resultsReporting.ts"() {
     "use strict";
-    import_chalk47 = __toESM(require("chalk"));
+    import_chalk48 = __toESM(require("chalk"));
     init_runtimeParity();
     init_runFormatting();
     init_support();
@@ -34768,14 +34936,14 @@ var init_resultsReporting = __esm({
       const rows = summaries.map((summary) => {
         const profit = `${summary.netProfit.toFixed(2)}$`;
         const avgTrade = `${summary.avgTradeProfit.toFixed(2)}$`;
-        const profitColor = summary.netProfit > 0 ? import_chalk47.default.green : summary.netProfit < 0 ? import_chalk47.default.red : import_chalk47.default.gray;
-        const avgTradeColor = summary.avgTradeProfit > 0 ? import_chalk47.default.green : summary.avgTradeProfit < 0 ? import_chalk47.default.red : import_chalk47.default.gray;
+        const profitColor = summary.netProfit > 0 ? import_chalk48.default.green : summary.netProfit < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
+        const avgTradeColor = summary.avgTradeProfit > 0 ? import_chalk48.default.green : summary.avgTradeProfit < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
         return [
-          import_chalk47.default.blue(summary.strategyName),
-          import_chalk47.default.yellow(String(summary.tickers)),
-          import_chalk47.default.yellow(String(summary.tickersWithTrades)),
-          import_chalk47.default.cyan(String(summary.orders)),
-          import_chalk47.default.cyan(
+          import_chalk48.default.blue(summary.strategyName),
+          import_chalk48.default.yellow(String(summary.tickers)),
+          import_chalk48.default.yellow(String(summary.tickersWithTrades)),
+          import_chalk48.default.cyan(String(summary.orders)),
+          import_chalk48.default.cyan(
             `${summary.wins}/${summary.losses} (${summary.winRate.toFixed(2)}%)`
           ),
           profitColor(profit),
@@ -34795,12 +34963,12 @@ var init_resultsReporting = __esm({
 });
 
 // src/lib/runtimeTradeSync.ts
-var import_constants18, import_time10, import_redis20, CLOSED_PNL_LIMIT, CLOSED_PNL_RECONCILIATION_LOOKBACK_MS, EXCHANGE_HISTORY_MAX_RANGE_MS, isRuntimeTradeSyncFallbackClose, splitExchangeHistoryTimeRange, formatRuntimeTradeSyncError, loadClosedPnlRows, consumeClosedPnlMatch, isRuntimeTradeInConnectorScope, syncRuntimeTrades;
+var import_constants18, import_time12, import_redis20, CLOSED_PNL_LIMIT, CLOSED_PNL_RECONCILIATION_LOOKBACK_MS, EXCHANGE_HISTORY_MAX_RANGE_MS, isRuntimeTradeSyncFallbackClose, splitExchangeHistoryTimeRange, formatRuntimeTradeSyncError, loadClosedPnlRows, consumeClosedPnlMatch, isRuntimeTradeInConnectorScope, syncRuntimeTrades;
 var init_runtimeTradeSync = __esm({
   "src/lib/runtimeTradeSync.ts"() {
     "use strict";
     import_constants18 = require("@tradejs/core/constants");
-    import_time10 = require("@tradejs/core/time");
+    import_time12 = require("@tradejs/core/time");
     import_redis20 = require("@tradejs/infra/redis");
     CLOSED_PNL_LIMIT = 100;
     CLOSED_PNL_RECONCILIATION_LOOKBACK_MS = 24 * 60 * 60 * 1e3;
@@ -35007,7 +35175,7 @@ var init_runtimeTradeSync = __esm({
           await (0, import_redis20.setHashJsonField)(
             import_redis20.redisKeys.runtimeTradeBucket(
               userName3,
-              (0, import_time10.getRuntimeStorageDayKey)(trade.entryTimestamp)
+              (0, import_time12.getRuntimeStorageDayKey)(trade.entryTimestamp)
             ),
             trade.orderId,
             nextTrade2,
@@ -35045,7 +35213,7 @@ var init_runtimeTradeSync = __esm({
           (0, import_redis20.setHashJsonField)(
             import_redis20.redisKeys.runtimeTradeBucket(
               userName3,
-              (0, import_time10.getRuntimeStorageDayKey)(trade.entryTimestamp)
+              (0, import_time12.getRuntimeStorageDayKey)(trade.entryTimestamp)
             ),
             trade.orderId,
             nextTrade,
@@ -35054,7 +35222,7 @@ var init_runtimeTradeSync = __esm({
           (0, import_redis20.setHashJsonField)(
             import_redis20.redisKeys.runtimeClosedTradeBucket(
               userName3,
-              (0, import_time10.getRuntimeStorageDayKey)(nextTrade.exitTimestamp)
+              (0, import_time12.getRuntimeStorageDayKey)(nextTrade.exitTimestamp)
             ),
             trade.orderId,
             nextTrade,
@@ -35805,49 +35973,14 @@ var init_runtimeParityDetails = __esm({
   }
 });
 
-// src/lib/replay/runtimeComparison.ts
-var import_chalk48, import_time11, getReplayEntryTimestampCompareOffsetMs, buildReplaySignalEvaluations, lineageScopeKey, buildExpectedLineageByScope, hasExpectedLineage, filterReplayComparisonByLineage, formatDrilldownSummary, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, summarizeBacktestPnlByStrategy, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, buildPriceDeltaPct3, loadExchangeEntriesForComparison, compareExchangeEntriesToBacktest, findExchangeRuntimeOutcome, splitExchangeMatchesByRuntimeOrderStatus, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
-var init_runtimeComparison = __esm({
-  "src/lib/replay/runtimeComparison.ts"() {
+// src/lib/replay/runtimeComparisonCalculations.ts
+var lineageScopeKey, buildExpectedLineageByScope, hasExpectedLineage, filterReplayComparisonByLineage, buildPriceDeltaPct3, compareExchangeEntriesToBacktest, findExchangeRuntimeOutcome, hasLineageLinkedRuntimeOutcome, splitExchangeMatchesByRuntimeOrderStatus, summarizeBacktestPnlByStrategy, buildExchangeComparisonRows, buildRuntimeComparisonRows;
+var init_runtimeComparisonCalculations = __esm({
+  "src/lib/replay/runtimeComparisonCalculations.ts"() {
     "use strict";
-    import_chalk48 = __toESM(require("chalk"));
-    import_time11 = require("@tradejs/core/time");
     init_runtimeParity();
-    init_paritySummary();
-    init_runtimeRedis();
-    init_runtimeSignalsLoader();
-    init_runtimeTradeSync();
-    init_runFormatting();
     init_runtimeParityDetails();
-    init_runState();
-    init_cliConfig2();
-    init_runtimeEvidenceSource();
-    init_support();
     init_runtimeLineage();
-    getReplayEntryTimestampCompareOffsetMs = () => {
-      const intervalMinutes = Number(replayInterval);
-      return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 60 * 1e3 : 15 * 60 * 1e3;
-    };
-    buildReplaySignalEvaluations = (signals2) => signals2.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 } : {}
-    }));
     lineageScopeKey = ({
       strategy,
       symbol,
@@ -35867,12 +36000,7 @@ var init_runtimeComparison = __esm({
     }) => runtimeLineagesComparable(
       lineage,
       expectedByScope.get(
-        lineageScopeKey({
-          strategy,
-          symbol,
-          deploymentId,
-          accountId
-        })
+        lineageScopeKey({ strategy, symbol, deploymentId, accountId })
       )
     );
     filterReplayComparisonByLineage = ({
@@ -35994,13 +36122,7 @@ var init_runtimeComparison = __esm({
           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)
@@ -36009,208 +36131,12 @@ var init_runtimeComparison = __esm({
         }
       };
     };
-    formatDrilldownSummary = (summary) => Object.entries(summary).filter(([, count]) => count > 0).map(([classification, count]) => `${classification}=${count}`).join(", ");
-    toFiniteNumberOrNull4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-    sumOptionalNumbers = (values) => {
-      let sum3 = 0;
-      let hasValue = false;
-      for (const value of values) {
-        if (typeof value !== "number" || !Number.isFinite(value)) {
-          continue;
-        }
-        sum3 += value;
-        hasValue = true;
-      }
-      return hasValue ? Number(sum3.toFixed(12)) : null;
-    };
-    firstFiniteNumber = (values) => {
-      for (const value of values) {
-        if (typeof value === "number" && Number.isFinite(value)) {
-          return value;
-        }
-      }
-      return null;
-    };
-    firstString = (values) => values.find((value) => typeof value === "string" && value.trim());
-    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;
-    };
-    getExchangeExecutionMergeKey = (entry) => {
-      const orderId = firstString([entry.orderId, entry.orderLinkId]);
-      return orderId ? `${entry.symbol}::${entry.direction}::${orderId}` : null;
-    };
-    mergeExchangeExecutionGroup = (group) => {
-      const [first] = group;
-      const qty = sumOptionalNumbers(group.map((entry) => entry.qty)) ?? first.qty;
-      const weightedPriceSum = group.reduce((sum3, entry) => {
-        const entryQty = toFiniteNumberOrNull4(entry.qty);
-        const entryPrice2 = toFiniteNumberOrNull4(entry.entryPrice);
-        return entryQty != null && entryPrice2 != null ? sum3 + entryQty * entryPrice2 : sum3;
-      }, 0);
-      const entryPrice = qty > 0 && weightedPriceSum > 0 ? Number((weightedPriceSum / qty).toFixed(12)) : firstFiniteNumber(group.map((entry) => entry.entryPrice));
-      const openFee = sumOptionalNumbers(group.map((entry) => entry.openFee));
-      const closeFee = sumOptionalNumbers(group.map((entry) => entry.closeFee));
-      const fundingFee = firstFiniteNumber(group.map((entry) => entry.fundingFee));
-      const totalFee = sumOptionalNumbers([openFee, closeFee, fundingFee]) ?? firstFiniteNumber(group.map((entry) => entry.totalFee));
-      return {
-        symbol: first.symbol,
-        direction: first.direction,
-        qty,
-        entryPrice,
-        entryTimestamp: Math.min(...group.map((entry) => entry.entryTimestamp)),
-        ...firstString(group.map((entry) => entry.orderId)) ? { orderId: firstString(group.map((entry) => entry.orderId)) } : {},
-        ...firstString(group.map((entry) => entry.orderLinkId)) ? { orderLinkId: firstString(group.map((entry) => entry.orderLinkId)) } : {},
-        ...firstFiniteNumber(group.map((entry) => entry.takeProfitPrice)) != null ? {
-          takeProfitPrice: firstFiniteNumber(
-            group.map((entry) => entry.takeProfitPrice)
-          )
-        } : {},
-        ...firstFiniteNumber(group.map((entry) => entry.stopLossPrice)) != null ? {
-          stopLossPrice: firstFiniteNumber(
-            group.map((entry) => entry.stopLossPrice)
-          )
-        } : {},
-        ...firstFiniteNumber(group.map((entry) => entry.exitPrice)) != null ? { exitPrice: firstFiniteNumber(group.map((entry) => entry.exitPrice)) } : {},
-        ...firstFiniteNumber(group.map((entry) => entry.exitTimestamp)) != null ? {
-          exitTimestamp: firstFiniteNumber(
-            group.map((entry) => entry.exitTimestamp)
-          )
-        } : {},
-        ...sumOptionalNumbers(group.map((entry) => entry.closedPnl)) != null ? { closedPnl: sumOptionalNumbers(group.map((entry) => entry.closedPnl)) } : {},
-        ...openFee != null ? { openFee } : {},
-        ...closeFee != null ? { closeFee } : {},
-        ...fundingFee != null ? { fundingFee } : {},
-        ...totalFee != null ? { totalFee } : {}
-      };
-    };
-    mergeExchangeEntryExecutions = (rows) => {
-      const mergedRows = [];
-      const groups = /* @__PURE__ */ new Map();
-      for (const row of rows) {
-        const key = getExchangeExecutionMergeKey(row);
-        if (!key) {
-          mergedRows.push(row);
-          continue;
-        }
-        const group = groups.get(key) ?? [];
-        group.push(row);
-        groups.set(key, group);
-      }
-      for (const group of groups.values()) {
-        mergedRows.push(
-          group.length === 1 ? group[0] : mergeExchangeExecutionGroup(group)
-        );
-      }
-      return mergedRows.sort(
-        (left, right) => left.entryTimestamp - right.entryTimestamp
-      );
-    };
-    loadExchangeEntryRows = async ({
-      connector,
-      startTime,
-      endTime
-    }) => {
-      if (typeof connector.getEntryExecutions !== "function") {
-        console.log(
-          import_chalk48.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_chalk48.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_chalk48.default.yellow(
-              `runtime compare: getEntryExecutions failed: ${formatRuntimeTradeSyncError(error)}`
-            )
-          );
-        }
-      }
-      return mergeExchangeEntryExecutions(rows);
-    };
     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);
     };
-    loadExchangeEntriesForComparison = async ({
-      connector,
-      startTime,
-      endTime
-    }) => {
-      const entryRows = await loadExchangeEntryRows({
-        connector,
-        startTime,
-        endTime
-      });
-      const closedPnlRows = await loadClosedPnlRows({
-        connector,
-        startTime,
-        endTime,
-        callbacks: {
-          onUnsupported: () => {
-            console.log(
-              import_chalk48.default.yellow(
-                "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
-              )
-            );
-          },
-          onCapped: () => {
-            console.log(
-              import_chalk48.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_chalk48.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
-        };
-      });
-    };
     compareExchangeEntriesToBacktest = ({
       exchangeEntries,
       backtestEntries,
@@ -36243,30 +36169,20 @@ var init_runtimeComparison = __esm({
         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
-        }));
+        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;
-            }
+            if (candidate.used) continue;
             const diff = Math.abs(
               getBacktestParityComparisonTimestamp(
                 candidate.entry,
                 backtestTimestampOffsetMs
               ) - exchangeEntry.entryTimestamp
             );
-            if (diff > toleranceMs || diff >= bestDiff) {
-              continue;
-            }
+            if (diff > toleranceMs || diff >= bestDiff) continue;
             bestIndex = index;
             bestDiff = diff;
           }
@@ -36289,9 +36205,7 @@ var init_runtimeComparison = __esm({
         }
       }
       for (const entry of backtestEntries) {
-        if (!matchedBacktestEntries.has(entry)) {
-          backtestOnly.push(entry);
-        }
+        if (!matchedBacktestEntries.has(entry)) backtestOnly.push(entry);
       }
       matched.sort(
         (left, right) => left.exchange.entryTimestamp - right.exchange.entryTimestamp || left.backtest.strategy.localeCompare(right.backtest.strategy)
@@ -36300,11 +36214,7 @@ var init_runtimeComparison = __esm({
         (left, right) => left.entryTimestamp - right.entryTimestamp
       );
       backtestOnly.sort((left, right) => left.timestamp - right.timestamp);
-      return {
-        matched,
-        exchangeOnly,
-        backtestOnly
-      };
+      return { matched, exchangeOnly, backtestOnly };
     };
     findExchangeRuntimeOutcome = ({
       exchangeEntry,
@@ -36324,59 +36234,496 @@ var init_runtimeComparison = __esm({
           });
         }
       }
-      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
+      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;
+    };
+    hasLineageLinkedRuntimeOutcome = ({
+      exchangeEntry,
+      strategyName,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      toleranceMs,
+      signalTimestampOffsetMs
+    }) => findExchangeRuntimeOutcome({
+      exchangeEntry,
+      strategyName,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      toleranceMs,
+      signalTimestampOffsetMs
+    }) != null;
+    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 };
+    };
+    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;
+    };
+    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: backtest2 }) => backtest2),
+        ...orderFailed.map(({ backtest: backtest2 }) => backtest2)
+      ]);
+      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));
+    };
+    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_chalk49, import_time13, formatDrilldownSummary, colorizeRows, buildReplayComparisonReport, buildNoExchangeEntriesReport, buildNoRuntimeTradesReport, writeReplayComparisonReport;
+var init_runtimeComparisonReporting = __esm({
+  "src/lib/replay/runtimeComparisonReporting.ts"() {
+    "use strict";
+    import_chalk49 = __toESM(require("chalk"));
+    import_time13 = require("@tradejs/core/time");
+    init_runFormatting();
+    init_support();
+    formatDrilldownSummary = (summary) => Object.entries(summary).filter(([, count]) => count > 0).map(([classification, count]) => `${classification}=${count}`).join(", ");
+    colorizeRows = (rows) => rows.map((row) => {
+      const btPnlColor = row.backtestNetProfit > 0 ? import_chalk49.default.green : row.backtestNetProfit < 0 ? import_chalk49.default.red : import_chalk49.default.gray;
+      const rtPnlColor = row.runtimePnl > 0 ? import_chalk49.default.green : row.runtimePnl < 0 ? import_chalk49.default.red : import_chalk49.default.gray;
+      return [
+        import_chalk49.default.blue(row.strategyName),
+        import_chalk49.default.cyan(String(row.backtestEntries)),
+        btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
+        import_chalk49.default.yellow(String(row.runtimeTrades)),
+        rtPnlColor(`${row.runtimePnl.toFixed(2)}$`),
+        import_chalk49.default.green(String(row.matched)),
+        import_chalk49.default.red(String(row.orderFailed)),
+        import_chalk49.default.yellow(String(row.runtimeOnly)),
+        import_chalk49.default.magenta(String(row.backtestOnly)),
+        import_chalk49.default.red(String(getReplayRuntimeUnmatchedCount(row)))
+      ];
+    });
+    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_chalk49.default.gray(
+            `Mismatch drilldown: ${runtimeOnlyLabel}=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
+          )
+        );
+      }
+      lines.push("");
+      return lines;
+    };
+    buildNoExchangeEntriesReport = ({
+      connectorName,
+      window
+    }) => [
+      "",
+      import_chalk49.default.yellow(
+        `SIGNALS REPLAY VS EXCHANGE: no lineage-linked exchange entry executions found for ${connectorName} in ${(0, import_time13.formatUnix)(
+          window.start
+        )} -> ${(0, import_time13.formatUnix)(window.end)}`
+      ),
+      ""
+    ];
+    buildNoRuntimeTradesReport = ({
+      connectorName,
+      window
+    }) => [
+      "",
+      import_chalk49.default.yellow(
+        `SIGNALS REPLAY VS RUNTIME: no local runtime trades found for ${connectorName} in ${(0, import_time13.formatUnix)(
+          window.start
+        )} -> ${(0, import_time13.formatUnix)(window.end)} with matching lineage; checking lineage-linked exchange executions`
+      ),
+      ""
+    ];
+    writeReplayComparisonReport = (lines) => {
+      for (const line of lines) {
+        console.log(line);
+      }
+    };
+  }
+});
+
+// src/lib/replay/runtimeComparison.ts
+var import_chalk50, getReplayEntryTimestampCompareOffsetMs, buildReplaySignalEvaluations, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, loadExchangeEntriesForComparison, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
+var init_runtimeComparison = __esm({
+  "src/lib/replay/runtimeComparison.ts"() {
+    "use strict";
+    import_chalk50 = __toESM(require("chalk"));
+    init_runtimeParity();
+    init_paritySummary();
+    init_runtimeRedis();
+    init_runtimeSignalsLoader();
+    init_runtimeTradeSync();
+    init_runtimeParityDetails();
+    init_runState();
+    init_cliConfig2();
+    init_runtimeEvidenceSource();
+    init_support();
+    init_runtimeComparisonCalculations();
+    init_runtimeComparisonReporting();
+    init_runtimeComparisonCalculations();
+    getReplayEntryTimestampCompareOffsetMs = () => {
+      const intervalMinutes = Number(replayInterval);
+      return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 60 * 1e3 : 15 * 60 * 1e3;
+    };
+    buildReplaySignalEvaluations = (signals2) => signals2.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 } : {}
+    }));
+    toFiniteNumberOrNull4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+    sumOptionalNumbers = (values) => {
+      let sum3 = 0;
+      let hasValue = false;
+      for (const value of values) {
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          continue;
+        }
+        sum3 += value;
+        hasValue = true;
+      }
+      return hasValue ? Number(sum3.toFixed(12)) : null;
+    };
+    firstFiniteNumber = (values) => {
+      for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+          return value;
+        }
+      }
+      return null;
+    };
+    firstString = (values) => values.find((value) => typeof value === "string" && value.trim());
+    getExchangeExecutionMergeKey = (entry) => {
+      const orderId = firstString([entry.orderId, entry.orderLinkId]);
+      return orderId ? `${entry.symbol}::${entry.direction}::${orderId}` : null;
+    };
+    mergeExchangeExecutionGroup = (group) => {
+      const [first] = group;
+      const qty = sumOptionalNumbers(group.map((entry) => entry.qty)) ?? first.qty;
+      const weightedPriceSum = group.reduce((sum3, entry) => {
+        const entryQty = toFiniteNumberOrNull4(entry.qty);
+        const entryPrice2 = toFiniteNumberOrNull4(entry.entryPrice);
+        return entryQty != null && entryPrice2 != null ? sum3 + entryQty * entryPrice2 : sum3;
+      }, 0);
+      const entryPrice = qty > 0 && weightedPriceSum > 0 ? Number((weightedPriceSum / qty).toFixed(12)) : firstFiniteNumber(group.map((entry) => entry.entryPrice));
+      const openFee = sumOptionalNumbers(group.map((entry) => entry.openFee));
+      const closeFee = sumOptionalNumbers(group.map((entry) => entry.closeFee));
+      const fundingFee = firstFiniteNumber(group.map((entry) => entry.fundingFee));
+      const totalFee = sumOptionalNumbers([openFee, closeFee, fundingFee]) ?? firstFiniteNumber(group.map((entry) => entry.totalFee));
+      return {
+        symbol: first.symbol,
+        direction: first.direction,
+        qty,
+        entryPrice,
+        entryTimestamp: Math.min(...group.map((entry) => entry.entryTimestamp)),
+        ...firstString(group.map((entry) => entry.orderId)) ? { orderId: firstString(group.map((entry) => entry.orderId)) } : {},
+        ...firstString(group.map((entry) => entry.orderLinkId)) ? { orderLinkId: firstString(group.map((entry) => entry.orderLinkId)) } : {},
+        ...firstFiniteNumber(group.map((entry) => entry.takeProfitPrice)) != null ? {
+          takeProfitPrice: firstFiniteNumber(
+            group.map((entry) => entry.takeProfitPrice)
+          )
+        } : {},
+        ...firstFiniteNumber(group.map((entry) => entry.stopLossPrice)) != null ? {
+          stopLossPrice: firstFiniteNumber(
+            group.map((entry) => entry.stopLossPrice)
+          )
+        } : {},
+        ...firstFiniteNumber(group.map((entry) => entry.exitPrice)) != null ? { exitPrice: firstFiniteNumber(group.map((entry) => entry.exitPrice)) } : {},
+        ...firstFiniteNumber(group.map((entry) => entry.exitTimestamp)) != null ? {
+          exitTimestamp: firstFiniteNumber(
+            group.map((entry) => entry.exitTimestamp)
+          )
+        } : {},
+        ...sumOptionalNumbers(group.map((entry) => entry.closedPnl)) != null ? { closedPnl: sumOptionalNumbers(group.map((entry) => entry.closedPnl)) } : {},
+        ...openFee != null ? { openFee } : {},
+        ...closeFee != null ? { closeFee } : {},
+        ...fundingFee != null ? { fundingFee } : {},
+        ...totalFee != null ? { totalFee } : {}
+      };
+    };
+    mergeExchangeEntryExecutions = (rows) => {
+      const mergedRows = [];
+      const groups = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const key = getExchangeExecutionMergeKey(row);
+        if (!key) {
+          mergedRows.push(row);
+          continue;
+        }
+        const group = groups.get(key) ?? [];
+        group.push(row);
+        groups.set(key, group);
+      }
+      for (const group of groups.values()) {
+        mergedRows.push(
+          group.length === 1 ? group[0] : mergeExchangeExecutionGroup(group)
+        );
+      }
+      return mergedRows.sort(
+        (left, right) => left.entryTimestamp - right.entryTimestamp
+      );
+    };
+    loadExchangeEntryRows = async ({
+      connector,
+      startTime,
+      endTime
+    }) => {
+      if (typeof connector.getEntryExecutions !== "function") {
+        console.log(
+          import_chalk50.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_chalk50.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_chalk50.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);
     };
-    splitExchangeMatchesByRuntimeOrderStatus = ({
-      matched,
-      strategyNameByOrderLinkKey,
-      runtimeSignals,
-      runtimeSignalEvaluations,
-      toleranceMs,
-      signalTimestampOffsetMs
+    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_chalk50.default.yellow(
+                "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
+              )
+            );
+          },
+          onCapped: () => {
+            console.log(
+              import_chalk50.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_chalk50.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
+        };
+      });
     };
     saveAndPrintReplayExchangeComparison = async ({
       liveStrategySummaries,
@@ -36396,7 +36743,6 @@ var init_runtimeComparison = __esm({
       const strategyNameByOrderLinkKey = buildStrategyNameByOrderLinkKey(
         liveStrategySummaries.map((summary) => summary.strategyName)
       );
-      const exchangeOutcomeByEntry = /* @__PURE__ */ new Map();
       const exchangeEntries = rawExchangeEntries.filter((entry) => {
         const strategyName = resolveReplayStrategyNameFromExchangeEntry({
           exchangeEntry: entry,
@@ -36405,7 +36751,7 @@ var init_runtimeComparison = __esm({
         if (!strategyName) {
           return false;
         }
-        const outcome = findExchangeRuntimeOutcome({
+        return hasLineageLinkedRuntimeOutcome({
           exchangeEntry: entry,
           strategyName,
           runtimeSignals,
@@ -36413,24 +36759,18 @@ var init_runtimeComparison = __esm({
           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_chalk48.default.yellow(
-            `SIGNALS REPLAY VS EXCHANGE: no lineage-linked exchange entry executions found for ${connectorName} in ${(0, import_time11.formatUnix)(
-              window.start
-            )} -> ${(0, import_time11.formatUnix)(window.end)}`
-          )
+        writeReplayComparisonReport(
+          buildNoExchangeEntriesReport({
+            connectorName,
+            window
+          })
         );
-        console.log("");
         const details2 = buildReplayExchangeComparisonDetails({
           matched: [],
           exchangeOnly: [],
@@ -36445,6 +36785,16 @@ var init_runtimeComparison = __esm({
           replaySignals,
           replaySignalEvaluations
         });
+        const emptyRowsByStrategy = new Map(
+          buildExchangeComparisonRows({
+            liveStrategySummaries,
+            backtestEntries,
+            matched: [],
+            orderFailed: [],
+            exchangeOnly: [],
+            strategyNameByOrderLinkKey
+          }).map((row) => [row.strategyName, row])
+        );
         return {
           mode: "exchange",
           syncedTradesCount: 0,
@@ -36457,21 +36807,9 @@ var init_runtimeComparison = __esm({
           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({
@@ -36488,62 +36826,6 @@ var init_runtimeComparison = __esm({
         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,
@@ -36559,45 +36841,22 @@ var init_runtimeComparison = __esm({
         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_chalk48.default.green : row.backtestNetProfit < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
-        const rtPnlColor = row.runtimePnl > 0 ? import_chalk48.default.green : row.runtimePnl < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
-        return [
-          import_chalk48.default.blue(row.strategyName),
-          import_chalk48.default.cyan(String(row.backtestEntries)),
-          btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
-          import_chalk48.default.yellow(String(row.runtimeTrades)),
-          rtPnlColor(`${row.runtimePnl.toFixed(2)}$`),
-          import_chalk48.default.green(String(row.matched)),
-          import_chalk48.default.red(String(row.orderFailed)),
-          import_chalk48.default.yellow(String(row.runtimeOnly)),
-          import_chalk48.default.magenta(String(row.backtestOnly)),
-          import_chalk48.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_chalk48.default.gray(
-            `Mismatch drilldown: exchangeOnly=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
-          )
-        );
-      }
-      console.log("");
       return {
         mode: "exchange",
         syncedTradesCount: exchangeEntries.length,
@@ -36664,7 +36923,7 @@ var init_runtimeComparison = __esm({
       ]);
       if (runtimeEvidence2) {
         console.log(
-          import_chalk48.default.gray(
+          import_chalk50.default.gray(
             `runtime compare: using immutable evidence ${runtimeEvidence2.path}`
           )
         );
@@ -36678,7 +36937,7 @@ var init_runtimeComparison = __esm({
         openPositionCallbacks: {
           onError: (error) => {
             console.log(
-              import_chalk48.default.yellow(
+              import_chalk50.default.yellow(
                 `runtime compare: getOpenPositionPnl failed: ${formatRuntimeTradeSyncError(error)}; continuing without open-position mark prices`
               )
             );
@@ -36687,21 +36946,21 @@ var init_runtimeComparison = __esm({
         closedPnlCallbacks: {
           onUnsupported: () => {
             console.log(
-              import_chalk48.default.yellow(
+              import_chalk50.default.yellow(
                 "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
               )
             );
           },
           onCapped: () => {
             console.log(
-              import_chalk48.default.yellow(
+              import_chalk50.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_chalk48.default.yellow(
+              import_chalk50.default.yellow(
                 `runtime compare: getClosedPnl failed: ${formatRuntimeTradeSyncError(error)}`
               )
             );
@@ -36721,15 +36980,9 @@ var init_runtimeComparison = __esm({
         (trade) => trade.entryTimestamp >= window.start && trade.entryTimestamp < window.end && relevantStrategies.has(trade.strategy)
       );
       if (!windowRuntimeTrades.length && !runtimeEvidence2) {
-        console.log("");
-        console.log(
-          import_chalk48.default.yellow(
-            `SIGNALS REPLAY VS RUNTIME: no local runtime trades found for ${connectorName} in ${(0, import_time11.formatUnix)(
-              window.start
-            )} -> ${(0, import_time11.formatUnix)(window.end)} with matching lineage; checking lineage-linked exchange executions`
-          )
+        writeReplayComparisonReport(
+          buildNoRuntimeTradesReport({ connectorName, window })
         );
-        console.log("");
         return saveAndPrintReplayExchangeComparison({
           liveStrategySummaries,
           backtestEntries: comparableBacktestEntries,
@@ -36741,9 +36994,6 @@ var init_runtimeComparison = __esm({
         });
       }
       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({
@@ -36773,68 +37023,20 @@ var init_runtimeComparison = __esm({
         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_chalk48.default.green : row.backtestNetProfit < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
-        const rtPnlColor = row.runtimePnl > 0 ? import_chalk48.default.green : row.runtimePnl < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
-        return [
-          import_chalk48.default.blue(row.strategyName),
-          import_chalk48.default.cyan(String(row.backtestEntries)),
-          btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
-          import_chalk48.default.yellow(String(row.runtimeTrades)),
-          rtPnlColor(`${row.runtimePnl.toFixed(2)}$`),
-          import_chalk48.default.green(String(row.matched)),
-          import_chalk48.default.red(String(row.orderFailed)),
-          import_chalk48.default.yellow(String(row.runtimeOnly)),
-          import_chalk48.default.magenta(String(row.backtestOnly)),
-          import_chalk48.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_chalk48.default.gray(
-            `Mismatch drilldown: runtimeOnly=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
-          )
-        );
-      }
-      console.log("");
       return {
         mode: "runtime",
         syncedTradesCount: syncedRuntimeTrades.length,
@@ -37280,14 +37482,14 @@ var init_outputReport = __esm({
 });
 
 // src/scripts/replayRunner.ts
-var import_chalk49, import_constants19, import_data5, import_time12, import_redis21, prepareReplayBinanceMarketContext, finishReplay, replayBacktest;
+var import_chalk51, import_constants19, import_data5, import_time14, import_redis21, prepareReplayBinanceMarketContext, finishReplay, replayBacktest;
 var init_replayRunner = __esm({
   "src/scripts/replayRunner.ts"() {
     "use strict";
-    import_chalk49 = __toESM(require("chalk"));
+    import_chalk51 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
     import_data5 = require("@tradejs/core/data");
-    import_time12 = require("@tradejs/core/time");
+    import_time14 = require("@tradejs/core/time");
     import_redis21 = require("@tradejs/infra/redis");
     init_runFormatting();
     init_runEnvironment();
@@ -37318,7 +37520,7 @@ var init_replayRunner = __esm({
         aiEnabled: preparedRun.aiEnabled,
         mlEnabled: preparedRun.mlEnabled,
         strategyNames: preparedRun.strategyNames,
-        log: (message) => console.log(import_chalk49.default.gray(message))
+        log: (message) => console.log(import_chalk51.default.gray(message))
       });
     };
     finishReplay = async ({
@@ -37346,9 +37548,9 @@ var init_replayRunner = __esm({
       const replayChartSnapshot = replayFlags.chart ? buildReplayChartSnapshot({
         replayResult,
         generatedAt: finishedAt.getTime(),
-        runLabel: `${(0, import_time12.formatUnix)(
+        runLabel: `${(0, import_time14.formatUnix)(
           replayResult.orderLog[0]?.timestamp ?? finishedAt.getTime()
-        )} -> ${(0, import_time12.formatUnix)(
+        )} -> ${(0, import_time14.formatUnix)(
           replayResult.orderLog[replayResult.orderLog.length - 1]?.timestamp ?? finishedAt.getTime()
         )}`
       }) : null;
@@ -37371,8 +37573,8 @@ var init_replayRunner = __esm({
         strategySnapshot: replayStrategySnapshot,
         runtimeComparison: replayRuntimeComparison
       });
-      console.log(import_chalk49.default.green(`Replay report: ${outputReport.markdownPath}`));
-      console.log(import_chalk49.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
+      console.log(import_chalk51.default.green(`Replay report: ${outputReport.markdownPath}`));
+      console.log(import_chalk51.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
       await (0, import_redis21.setData)(
         replayKey,
         {
@@ -37525,9 +37727,9 @@ var init_replayRunner = __esm({
         ),
         strategyNames: replayStrategies.map(({ strategyName }) => strategyName)
       });
-      console.log(import_chalk49.default.yellow(`tickers: ${preparedRun.tickers.length}`));
+      console.log(import_chalk51.default.yellow(`tickers: ${preparedRun.tickers.length}`));
       console.log(
-        import_chalk49.default.gray(
+        import_chalk51.default.gray(
           `mode: replay (${replayStrategies.map(({ strategyName }) => strategyName).join(", ")})`
         )
       );
@@ -38410,12 +38612,12 @@ var user_add_exports = {};
 __export(user_add_exports, {
   main: () => main47
 });
-var import_args34, import_chalk50, import_bcryptjs, import_redis22, flags31, main47;
+var import_args34, import_chalk52, import_bcryptjs, import_redis22, flags31, main47;
 var init_user_add = __esm({
   "src/scripts/user-add.ts"() {
     "use strict";
     import_args34 = __toESM(require("args"));
-    import_chalk50 = __toESM(require("chalk"));
+    import_chalk52 = __toESM(require("chalk"));
     import_bcryptjs = __toESM(require("bcryptjs"));
     import_redis22 = require("@tradejs/infra/redis");
     import_args34.default.example("yarn user-add -u myname -p 123456", "Create or update user");
@@ -38426,7 +38628,7 @@ var init_user_add = __esm({
       const userName3 = String(flags31.user || "").trim();
       const password = String(flags31.password || "");
       if (!userName3 || !password) {
-        console.error(import_chalk50.default.red("Missing -U <user> or -P <password>"));
+        console.error(import_chalk52.default.red("Missing -U <user> or -P <password>"));
         process.exit(1);
       }
       const passwordHash = await import_bcryptjs.default.hash(password, 10);
@@ -38440,7 +38642,7 @@ var init_user_add = __esm({
       await (0, import_redis22.setData)(import_redis22.redisKeys.user(userName3), next, {
         expire: 0
       });
-      console.log(import_chalk50.default.green(`User ${userName3} updated`));
+      console.log(import_chalk52.default.green(`User ${userName3} updated`));
       process.exit(0);
     };
   }