@tradejs/cli 3.1.19 → 3.1.20

package/dist/scripts/runtimeParity.js

@@ -38,9 +38,9 @@ module.exports = __toCommonJS(runtimeParity_exports);
 var import_config = require("dotenv/config");
 var import_node_crypto = require("crypto");
 var import_args = __toESM(require("args"));
-var import_chalk6 = __toESM(require("chalk"));
+var import_chalk7 = __toESM(require("chalk"));
 var import_constants3 = require("@tradejs/core/constants");
-var import_time3 = require("@tradejs/core/time");
+var import_time5 = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
 var import_redis3 = require("@tradejs/infra/redis");
 var import_cli3 = require("@tradejs/node/cli");
@@ -332,51 +332,6 @@ var normalizeCliArgv = (argv, legacyFlagMap) => argv.map((arg) => {
   return `${normalizedFlag}=${rest.join("=")}`;
 });
 
-// src/lib/paritySummary.ts
-var 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/runtimeRedis.ts
 var import_redis = require("@tradejs/infra/redis");
 var import_time = require("@tradejs/core/time");
@@ -4460,6 +4415,76 @@ var buildReplayTargets = async ({
   );
 };
 
+// src/lib/runtimeParity/evidence.ts
+var matchesSelection = (context, artifact) => (!context.strategy || artifact.strategy === context.strategy) && (!context.symbols || context.symbols.has(artifact.symbol));
+var 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 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 = [
   "gated_out",
@@ -4789,250 +4814,117 @@ var summarizeRuntimeOnlyClassifications = (classifiedEntries) => {
   return nonZero.join(", ");
 };
 
-// src/lib/runtimeModeConfig.ts
-var hasRuntimeEntryGateEnabled = (strategyConfig) => strategyConfig.AI_ENABLED === true || strategyConfig.ML_ENABLED === true;
-var resolveReplayStrategyEnv = ({
-  strategyConfig,
-  forceRuntimeGates = false
-}) => forceRuntimeGates || hasRuntimeEntryGateEnabled(strategyConfig) ? "PARITY" : "BACKTEST";
-var buildRuntimeModeStrategyConfig = ({
-  strategyConfig,
-  env,
-  interval: interval2,
-  makeOrders,
-  recordRuntimeTrades,
-  aiReplayAnalyses
-}) => ({
-  ...strategyConfig,
-  ENV: env,
-  MAKE_ORDERS: makeOrders,
-  INTERVAL: strategyConfig.INTERVAL ?? interval2,
-  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
-  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
-});
-
-// src/scripts/runtimeParity.ts
-import_args.default.option(["u", "user"], "Use user config", "root");
-import_args.default.option(
-  ["o", "connector"],
-  "Connector provider or name for parity replay (e.g. bybit, binance, coinbase, custom)",
-  "bybit"
-);
-import_args.default.option(["d", "days"], "Replay window in days", 3);
-import_args.default.option(
-  ["b", "startTime"],
-  "Explicit replay start timestamp (ms or seconds)"
-);
-import_args.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
-import_args.default.option(["s", "strategy"], "Only compare one strategy");
-import_args.default.option(
-  ["t", "tickers"],
-  "Replay comma-separated symbols for all configured strategies"
-);
-import_args.default.option(
-  ["C", "cacheOnly"],
-  "Do not refresh market history before replay",
-  false
-);
-import_args.default.option(
-  ["a", "toleranceBars"],
-  "Allowed entry timestamp drift in bars when matching runtime vs backtest",
-  1
-);
-import_args.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_args.default.option(
-  "runtimeGates",
-  "Force runtime AI/ML gates for all replay targets. Runtime-gated configs are replayed with gates by default.",
-  false
-);
-import_args.default.option(["N", "notify"], "Send parity summary to Telegram", false);
-import_args.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"
-});
-var flags = import_args.default.parse(process.argv);
-var interval = "15";
-var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
-var DEFAULT_LOOKBACK_DAYS = 3;
-var DETAIL_LIMIT = 10;
-var TELEGRAM_DETAIL_LIMIT = 5;
-var SUMMARY_TIMEZONE = "Europe/Moscow";
-var SUMMARY_TIMEZONE_LABEL = "MSK";
-var DEFAULT_REPLAY_ENV = flags.runtimeGates ? "PARITY" : "BACKTEST";
-var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-var formatMskDateTime = (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));
-var resolveParityConnectorName = async (value) => {
-  const connectorName = await (0, import_connectors5.resolveConnectorName)(value, projectRoot);
-  if (connectorName) {
-    return connectorName;
+// src/lib/runtimeParity/analysis.ts
+var 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
+    });
   }
-  import_logger.logger.warn(
-    'Unknown connector "%s". Fallback to %s.',
-    String(value || "").trim() || String(value),
-    import_connectors5.DEFAULT_CONNECTOR_NAME
+  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)
   );
-  return import_connectors5.DEFAULT_CONNECTOR_NAME;
 };
-var createConnector = async ({
-  userName,
-  connectorName
-}) => {
-  const connectorFactory = await (0, import_connectors5.getConnectorCreatorByName)(
-    connectorName,
-    projectRoot
+var analyzeRuntimeParity = (context) => {
+  const comparableRuntimeTrades = context.runtimeTrades.filter(
+    (trade) => context.successfulTargetKeys.has(toTargetKey(trade))
   );
-  if (!connectorFactory) {
-    throw new Error(`Connector "${connectorName}" is not registered`);
-  }
-  return await connectorFactory({ userName });
-};
-var 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;
-  });
-};
-var formatReplayEnvSummary = (configs) => {
-  let backtest = 0;
-  let parity = 0;
-  for (const config of configs) {
-    if (config.ENV === "PARITY") {
-      parity += 1;
-    } else {
-      backtest += 1;
-    }
-  }
-  if (parity > 0 && backtest > 0) {
-    return `MIXED (PARITY=${parity}, BACKTEST=${backtest})`;
-  }
-  if (parity > 0) {
-    return "PARITY";
-  }
-  return "BACKTEST";
-};
-var buildReplayConfig = async ({
-  userName,
-  strategy,
-  symbol,
-  replayInputsIndex,
-  toleranceMs
-}) => {
-  const [userConfig, strategyResults] = await Promise.all([
-    (0, import_redis3.getData)(import_redis3.redisKeys.strategyConfig(userName, strategy), {}),
-    (0, import_redis3.getData)(import_redis3.redisKeys.strategyResults(userName, 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 rawRuntimeEntries = extractRuntimeParityEntries(
+    comparableRuntimeTrades
+  );
+  const runtimeDedupe = dedupeRuntimeParityEntries(rawRuntimeEntries);
+  const runtimeEntries = runtimeDedupe.entries;
+  const comparison = compareTradeParityEntries({
+    runtimeEntries,
+    backtestEntries: context.backtestEntries,
+    toleranceMs: context.toleranceMs
   });
-  const strategyConfig = {
-    ...userConfig,
-    ...symbolConfig
-  };
-  return buildRuntimeModeStrategyConfig({
-    strategyConfig,
-    env: resolveReplayStrategyEnv({
-      strategyConfig,
-      forceRuntimeGates: Boolean(flags.runtimeGates)
-    }),
-    interval,
-    makeOrders: true,
-    recordRuntimeTrades: false,
-    aiReplayAnalyses
+  const classifiedBacktestOnly = classifyBacktestOnlyEntries({
+    entries: comparison.backtestOnly,
+    runtimeSignals: context.runtimeSignals,
+    runtimeSignalEvaluations: context.runtimeSignalEvaluations,
+    toleranceMs: context.toleranceMs
   });
-};
-var warmReplayHistory = async ({
-  userName,
-  connectorName,
-  targets,
-  preloadStart,
-  preloadEnd
-}) => {
-  const connector = await createConnector({ userName, connectorName });
-  const symbols = [...new Set(targets.map((target) => target.symbol))];
-  const warmStartedAt = Date.now();
-  console.log(
-    import_chalk6.default.gray(
-      `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time3.formatUnix)(preloadStart)} -> ${(0, import_time3.formatUnix)(preloadEnd)}`
-    )
-  );
-  const btcReferences = await loadBtcReferenceConnectors({
-    connectorName,
-    marketConnector: connector,
-    userName,
-    projectRoot,
-    shouldUseDedicatedReferences: true,
-    warn: (message) => import_logger.logger.warn(message)
+  const classifiedRuntimeOnly = classifyRuntimeOnlyEntries({
+    entries: comparison.runtimeOnly,
+    replaySignalEvaluations: context.replaySignalEvaluations,
+    backtestEntries: context.backtestEntries,
+    toleranceMs: context.toleranceMs
   });
-  await updateMarketHistoryWithBtcReferences({
-    marketConnector: connector,
-    connectorName,
-    btcReferences,
-    interval,
-    symbols,
-    preloadStart,
-    preloadEnd,
-    log: (message) => console.log(import_chalk6.default.gray(message))
+  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
   });
-  console.log(
-    import_chalk6.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
-  );
+  return {
+    comparableRuntimeTrades,
+    rawRuntimeEntries,
+    runtimeDedupe,
+    runtimeEntries,
+    comparison,
+    classifiedBacktestOnly,
+    classifiedRuntimeOnly,
+    matchedSummary,
+    strategyRows
+  };
 };
+
+// src/lib/runtimeParity/reportingShared.ts
+var import_time3 = require("@tradejs/core/time");
 var formatPercent = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${value.toFixed(2)}%`;
 var formatMinutes2 = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${(value / 6e4).toFixed(2)}m`;
 var formatEntryLabel = (entry) => `${entry.strategy} ${entry.symbol} ${entry.direction} ${(0, import_time3.formatUnix)(entry.timestamp)}`;
@@ -5052,16 +4944,11 @@ var formatSourceCountsSummary = (sourceCounts) => {
 };
 var 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)}...`;
 };
 var 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;
 };
@@ -5081,9 +4968,7 @@ var buildMismatchSummaryRows = ({
       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}`);
     }
@@ -5145,20 +5030,16 @@ var buildMismatchSummaryRows = ({
 };
 var 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 = (entry) => entry ? {
   id: entry.id,
   source: entry.source,
@@ -5301,34 +5182,12 @@ var getBacktestOnlyRecommendedChecks = (classification) => {
       ];
   }
 };
-var 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) {
+var 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,
@@ -5367,7 +5226,7 @@ var buildRuntimeParityMismatchAttachment = ({
         )
       }
     })),
-    ...classifiedBacktestOnly.map((item) => ({
+    ...context.classifiedBacktestOnly.map((item) => ({
       kind: "backtestOnly",
       strategy: item.entry.strategy,
       symbol: item.entry.symbol,
@@ -5413,40 +5272,37 @@ var buildRuntimeParityMismatchAttachment = ({
     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,
@@ -5454,7 +5310,7 @@ var buildRuntimeParityMismatchAttachment = ({
     })),
     cases,
     mismatches: {
-      runtimeOnly: classifiedRuntimeOnly.map((item) => ({
+      runtimeOnly: context.classifiedRuntimeOnly.map((item) => ({
         classification: item.classification,
         reason: item.reason,
         runtimeEntry: toSerializableTradeParityEntry(item.entry),
@@ -5467,7 +5323,7 @@ var buildRuntimeParityMismatchAttachment = ({
         ),
         nearestBacktestDriftMs: item.nearestBacktestEntryTimestampDiffMs
       })),
-      backtestOnly: classifiedBacktestOnly.map((item) => ({
+      backtestOnly: context.classifiedBacktestOnly.map((item) => ({
         classification: item.classification,
         reason: item.reason,
         backtestEntry: toSerializableTradeParityEntry(item.entry),
@@ -5481,15 +5337,93 @@ var buildRuntimeParityMismatchAttachment = ({
     }
   };
   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"
   };
 };
-var printRuntimeDuplicateDetails = (groups) => {
-  if (!groups.length) {
-    return;
+
+// src/lib/runtimeParity/reportingTerminal.ts
+var import_chalk6 = __toESM(require("chalk"));
+var import_time4 = require("@tradejs/core/time");
+var DETAIL_LIMIT = 10;
+var buildRuntimeParityTerminalReport = (context) => {
+  const mismatchRows = buildMismatchSummaryRows(context);
+  const strategyIssueRows = buildStrategyIssueRows(context.strategyRows);
+  const lines = [
+    import_chalk6.default.cyan("TradeJS runtime parity"),
+    `Window: ${(0, import_time4.formatUnix)(context.window.start)} -> ${(0, import_time4.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=${formatPercent(context.matchedSummary.avgPriceDeltaPct)} / ${formatPercent(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_chalk6.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_chalk6.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_chalk6.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_chalk6.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;
+};
+var writeRuntimeParityTerminalReport = (lines) => {
+  for (const line of lines) console.log(line);
+};
+var printRuntimeDuplicateDetails = (groups) => {
+  if (!groups.length) return;
   console.log("");
   console.log(import_chalk6.default.yellow("Runtime duplicates"));
   for (const group of groups.slice(0, DETAIL_LIMIT)) {
@@ -5503,9 +5437,7 @@ var printRuntimeDuplicateDetails = (groups) => {
   }
 };
 var printClassifiedBacktestOnlyDetails = (classifiedEntries) => {
-  if (!classifiedEntries.length) {
-    return;
-  }
+  if (!classifiedEntries.length) return;
   console.log("");
   console.log(import_chalk6.default.yellow("Backtest only"));
   for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
@@ -5520,9 +5452,7 @@ var printClassifiedBacktestOnlyDetails = (classifiedEntries) => {
   }
 };
 var printClassifiedRuntimeOnlyDetails = (classifiedEntries) => {
-  if (!classifiedEntries.length) {
-    return;
-  }
+  if (!classifiedEntries.length) return;
   console.log("");
   console.log(import_chalk6.default.yellow("Runtime only"));
   for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
@@ -5536,149 +5466,78 @@ var printClassifiedRuntimeOnlyDetails = (classifiedEntries) => {
     console.log(`- ... ${classifiedEntries.length - DETAIL_LIMIT} more`);
   }
 };
-var 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)
-  );
-};
-var 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
+
+// src/lib/runtimeParity/reportingTelegram.ts
+var TELEGRAM_DETAIL_LIMIT = 5;
+var SUMMARY_TIMEZONE = "Europe/Moscow";
+var SUMMARY_TIMEZONE_LABEL = "MSK";
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var formatMskDateTime = (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));
+var buildRuntimeParityMessage = ({
+  runtimeGatesEnabled,
+  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>${escapeHtml(formatMskDateTime(window.start))} - ${escapeHtml(formatMskDateTime(window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`
+    `<b>${escapeHtml(formatMskDateTime(context.window.start))} - ${escapeHtml(formatMskDateTime(context.window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`
   );
   lines.push("");
-  lines.push(`\u{1F50C} Connector: <b>${escapeHtml(connectorName)}</b>`);
-  lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml(replayEnv)}</b>`);
+  lines.push(`\u{1F50C} Connector: <b>${escapeHtml(context.connectorName)}</b>`);
+  lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml(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>${escapeHtml(formatSourceCountsSummary(sourceCounts))}</b>`
+    `\u2022 Sources: <b>${escapeHtml(formatSourceCountsSummary(context.sourceCounts))}</b>`
   );
   lines.push("");
   lines.push("\u{1F4C8} <b>Entries</b>");
   lines.push(
-    `\u2022 Runtime: <b>${escapeHtml(
-      formatRuntimeEntriesSummary({
-        rawRuntimeEntriesCount,
-        runtimeEntriesCount,
-        runtimeDuplicateEntriesCount
-      })
-    )}</b>`
+    `\u2022 Runtime: <b>${escapeHtml(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>${escapeHtml(formatPercent(matchedSummary.avgPriceDeltaPct))} / ${escapeHtml(formatPercent(matchedSummary.maxPriceDeltaPct))}</b>, time avg/max=<b>${escapeHtml(formatMinutes2(matchedSummary.avgTimestampDiffMs))} / ${escapeHtml(formatMinutes2(matchedSummary.maxTimestampDiffMs))}</b>`
+    `\u2022 Matched deltas: price avg/max=<b>${escapeHtml(formatPercent(context.matchedSummary.avgPriceDeltaPct))} / ${escapeHtml(formatPercent(context.matchedSummary.maxPriceDeltaPct))}</b>, time avg/max=<b>${escapeHtml(formatMinutes2(context.matchedSummary.avgTimestampDiffMs))} / ${escapeHtml(formatMinutes2(context.matchedSummary.maxTimestampDiffMs))}</b>`
   );
-  if (classifiedRuntimeOnly.length) {
+  if (context.classifiedRuntimeOnly.length) {
     lines.push(
-      `\u2022 Runtime-only classes: <code>${escapeHtml(summarizeRuntimeOnlyClassifications(classifiedRuntimeOnly))}</code>`
+      `\u2022 Runtime-only classes: <code>${escapeHtml(summarizeRuntimeOnlyClassifications(context.classifiedRuntimeOnly))}</code>`
     );
   }
-  if (classifiedBacktestOnly.length) {
+  if (context.classifiedBacktestOnly.length) {
     lines.push(
-      `\u2022 Backtest-only classes: <code>${escapeHtml(summarizeBacktestOnlyClassifications(classifiedBacktestOnly))}</code>`
+      `\u2022 Backtest-only classes: <code>${escapeHtml(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>${escapeHtml(item.line)}</code>`);
     }
@@ -5688,17 +5547,17 @@ var buildRuntimeParityMessage = ({
       );
     }
   }
-  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 ${escapeHtml(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) {
@@ -5712,17 +5571,17 @@ var buildRuntimeParityMessage = ({
       );
     }
   }
-  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>${escapeHtml(error.strategy)}</b> ${escapeHtml(error.symbol)}: <code>${escapeHtml(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`
       );
     }
   }
@@ -5732,7 +5591,6 @@ var buildRuntimeParityNoTargetsMessage = ({
   window,
   connectorName,
   replayEnv,
-  runtimeGatesEnabled: _runtimeGatesEnabled,
   userName
 }) => [
   "\u{1F9EA} <b>TradeJS runtime parity</b>",
@@ -5745,6 +5603,238 @@ var buildRuntimeParityNoTargetsMessage = ({
   "",
   `\u26A0\uFE0F No replay targets found for user <b>${escapeHtml(userName)}</b>.`
 ].join("\n");
+
+// src/lib/runtimeModeConfig.ts
+var hasRuntimeEntryGateEnabled = (strategyConfig) => strategyConfig.AI_ENABLED === true || strategyConfig.ML_ENABLED === true;
+var resolveReplayStrategyEnv = ({
+  strategyConfig,
+  forceRuntimeGates = false
+}) => forceRuntimeGates || hasRuntimeEntryGateEnabled(strategyConfig) ? "PARITY" : "BACKTEST";
+var buildRuntimeModeStrategyConfig = ({
+  strategyConfig,
+  env,
+  interval: interval2,
+  makeOrders,
+  recordRuntimeTrades,
+  aiReplayAnalyses
+}) => ({
+  ...strategyConfig,
+  ENV: env,
+  MAKE_ORDERS: makeOrders,
+  INTERVAL: strategyConfig.INTERVAL ?? interval2,
+  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
+  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
+});
+
+// src/scripts/runtimeParity.ts
+import_args.default.option(["u", "user"], "Use user config", "root");
+import_args.default.option(
+  ["o", "connector"],
+  "Connector provider or name for parity replay (e.g. bybit, binance, coinbase, custom)",
+  "bybit"
+);
+import_args.default.option(["d", "days"], "Replay window in days", 3);
+import_args.default.option(
+  ["b", "startTime"],
+  "Explicit replay start timestamp (ms or seconds)"
+);
+import_args.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
+import_args.default.option(["s", "strategy"], "Only compare one strategy");
+import_args.default.option(
+  ["t", "tickers"],
+  "Replay comma-separated symbols for all configured strategies"
+);
+import_args.default.option(
+  ["C", "cacheOnly"],
+  "Do not refresh market history before replay",
+  false
+);
+import_args.default.option(
+  ["a", "toleranceBars"],
+  "Allowed entry timestamp drift in bars when matching runtime vs backtest",
+  1
+);
+import_args.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_args.default.option(
+  "runtimeGates",
+  "Force runtime AI/ML gates for all replay targets. Runtime-gated configs are replayed with gates by default.",
+  false
+);
+import_args.default.option(["N", "notify"], "Send parity summary to Telegram", false);
+import_args.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"
+});
+var flags = import_args.default.parse(process.argv);
+var interval = "15";
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var DEFAULT_LOOKBACK_DAYS = 3;
+var DETAIL_LIMIT2 = 10;
+var DEFAULT_REPLAY_ENV = flags.runtimeGates ? "PARITY" : "BACKTEST";
+var resolveParityConnectorName = async (value) => {
+  const connectorName = await (0, import_connectors5.resolveConnectorName)(value, projectRoot);
+  if (connectorName) {
+    return connectorName;
+  }
+  import_logger.logger.warn(
+    'Unknown connector "%s". Fallback to %s.',
+    String(value || "").trim() || String(value),
+    import_connectors5.DEFAULT_CONNECTOR_NAME
+  );
+  return import_connectors5.DEFAULT_CONNECTOR_NAME;
+};
+var createConnector = async ({
+  userName,
+  connectorName
+}) => {
+  const connectorFactory = await (0, import_connectors5.getConnectorCreatorByName)(
+    connectorName,
+    projectRoot
+  );
+  if (!connectorFactory) {
+    throw new Error(`Connector "${connectorName}" is not registered`);
+  }
+  return await connectorFactory({ userName });
+};
+var 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;
+  });
+};
+var formatReplayEnvSummary = (configs) => {
+  let backtest = 0;
+  let parity = 0;
+  for (const config of configs) {
+    if (config.ENV === "PARITY") {
+      parity += 1;
+    } else {
+      backtest += 1;
+    }
+  }
+  if (parity > 0 && backtest > 0) {
+    return `MIXED (PARITY=${parity}, BACKTEST=${backtest})`;
+  }
+  if (parity > 0) {
+    return "PARITY";
+  }
+  return "BACKTEST";
+};
+var buildReplayConfig = async ({
+  userName,
+  strategy,
+  symbol,
+  replayInputsIndex,
+  toleranceMs
+}) => {
+  const [userConfig, strategyResults] = await Promise.all([
+    (0, import_redis3.getData)(import_redis3.redisKeys.strategyConfig(userName, strategy), {}),
+    (0, import_redis3.getData)(import_redis3.redisKeys.strategyResults(userName, 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(flags.runtimeGates)
+    }),
+    interval,
+    makeOrders: true,
+    recordRuntimeTrades: false,
+    aiReplayAnalyses
+  });
+};
+var warmReplayHistory = async ({
+  userName,
+  connectorName,
+  targets,
+  preloadStart,
+  preloadEnd
+}) => {
+  const connector = await createConnector({ userName, connectorName });
+  const symbols = [...new Set(targets.map((target) => target.symbol))];
+  const warmStartedAt = Date.now();
+  console.log(
+    import_chalk7.default.gray(
+      `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time5.formatUnix)(preloadStart)} -> ${(0, import_time5.formatUnix)(preloadEnd)}`
+    )
+  );
+  const btcReferences = await loadBtcReferenceConnectors({
+    connectorName,
+    marketConnector: connector,
+    userName,
+    projectRoot,
+    shouldUseDedicatedReferences: true,
+    warn: (message) => import_logger.logger.warn(message)
+  });
+  await updateMarketHistoryWithBtcReferences({
+    marketConnector: connector,
+    connectorName,
+    btcReferences,
+    interval,
+    symbols,
+    preloadStart,
+    preloadEnd,
+    log: (message) => console.log(import_chalk7.default.gray(message))
+  });
+  console.log(
+    import_chalk7.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
+  );
+};
 var runtimeParity = async () => {
   const window = resolveTimeWindow({
     days: flags.days ?? DEFAULT_LOOKBACK_DAYS,
@@ -5767,28 +5857,18 @@ var runtimeParity = async () => {
       userName: flags.user,
       connectorName
     });
-    const [allRuntimeTrades, allRuntimeSignals, allRuntimeSignalEvaluations] = await Promise.all([
-      loadRuntimeTrades(flags.user, {
-        startTime: window.start,
-        endTime: window.end
-      }),
-      loadRuntimeSignals(flags.user, {
-        startTime: window.start,
-        endTime: window.end
-      }),
-      loadRuntimeSignalEvaluations(flags.user, {
-        startTime: window.start,
-        endTime: window.end
-      })
-    ]);
-    const runtimeTrades = allRuntimeTrades.filter(
-      (trade) => trade.entryTimestamp >= window.start && trade.entryTimestamp <= window.end && (!flags.strategy || trade.strategy === flags.strategy) && (!requestedSymbolSet || requestedSymbolSet.has(trade.symbol))
-    );
-    const runtimeSignals = allRuntimeSignals.filter(
-      (signal) => signal.timestamp >= window.start && signal.timestamp <= window.end && (!flags.strategy || signal.strategy === flags.strategy) && (!requestedSymbolSet || requestedSymbolSet.has(signal.symbol))
-    );
-    const runtimeSignalEvaluations = allRuntimeSignalEvaluations.filter(
-      (evaluation) => evaluation.timestamp >= window.start && evaluation.timestamp <= window.end && (!flags.strategy || evaluation.strategy === flags.strategy) && (!requestedSymbolSet || requestedSymbolSet.has(evaluation.symbol))
+    const { runtimeTrades, runtimeSignals, runtimeSignalEvaluations } = await loadRuntimeParityEvidence(
+      {
+        userName: flags.user,
+        window,
+        strategy: flags.strategy,
+        symbols: requestedSymbolSet
+      },
+      {
+        loadRuntimeTrades,
+        loadRuntimeSignals,
+        loadRuntimeSignalEvaluations
+      }
     );
     const connectorSymbols = requestedSymbols.length ? requestedSymbols : await (0, import_cli3.getTickers)(parityConnector);
     const replayInputsIndex = buildReplayInputsIndex({
@@ -5805,8 +5885,8 @@ var runtimeParity = async () => {
     });
     if (!replayTargets.length) {
       console.log(
-        import_chalk6.default.yellow(
-          `No replay targets found for ${flags.user} in ${(0, import_time3.formatUnix)(window.start)} -> ${(0, import_time3.formatUnix)(window.end)}.`
+        import_chalk7.default.yellow(
+          `No replay targets found for ${flags.user} in ${(0, import_time5.formatUnix)(window.start)} -> ${(0, import_time5.formatUnix)(window.end)}.`
         )
       );
       if (flags.notify) {
@@ -5824,7 +5904,7 @@ var runtimeParity = async () => {
       return;
     }
     const sourceCounts = countReplayTargetSources(replayTargets);
-    const preloadStart = (0, import_time3.getBacktestPreloadStart)(
+    const preloadStart = (0, import_time5.getBacktestPreloadStart)(
       window.start,
       import_constants3.BACKTEST_PRELOAD_DAYS
     );
@@ -5833,7 +5913,7 @@ var runtimeParity = async () => {
       replayTargets.map((target) => target.symbol)
     ).size;
     console.log(
-      import_chalk6.default.gray(
+      import_chalk7.default.gray(
         `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
       )
     );
@@ -5868,7 +5948,7 @@ var runtimeParity = async () => {
       aiEnabled: hasParityAiTargets,
       mlEnabled: hasParityMlTargets,
       strategyNames: replayTargets.map((target) => target.strategy),
-      log: (message) => console.log(import_chalk6.default.gray(message))
+      log: (message) => console.log(import_chalk7.default.gray(message))
     });
     if (!flags.cacheOnly) {
       await warmReplayHistory({
@@ -5936,139 +6016,61 @@ var runtimeParity = async () => {
       }
       if (progressPosition === 1 || progressPosition === replayTargets.length || progressPosition % 25 === 0) {
         console.log(
-          import_chalk6.default.gray(
+          import_chalk7.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_chalk6.default.cyan("TradeJS runtime parity"));
-    console.log(
-      `Window: ${(0, import_time3.formatUnix)(window.start)} -> ${(0, import_time3.formatUnix)(window.end)} (${window.source})`
-    );
-    console.log(`Connector: ${connectorName}`);
-    console.log(
-      `Replay env: ${replayEnvSummary}${flags.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(flags.runtimeGates) || replayEnvSummary.includes("PARITY"),
+        runtimeGatesRequested: Boolean(flags.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=${formatPercent(summary.avgPriceDeltaPct)} / ${formatPercent(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_chalk6.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_chalk6.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 && !flags.runtimeGates) {
-      console.log("");
-      console.log(import_chalk6.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_chalk6.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 (flags.details) {
       printRuntimeDuplicateDetails(runtimeDedupe.duplicateGroups);
       printClassifiedRuntimeOnlyDetails(classifiedRuntimeOnly);