@tradejs/cli 1.0.6 → 1.0.9

package/dist/scripts/runtimeParity.js

@@ -0,0 +1,1688 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/runtimeParity.ts
+var runtimeParity_exports = {};
+__export(runtimeParity_exports, {
+  buildRuntimeParityMessage: () => buildRuntimeParityMessage,
+  runtimeParity: () => runtimeParity
+});
+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_chalk = __toESM(require("chalk"));
+var import_connectors = require("@tradejs/connectors");
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_logger = require("@tradejs/infra/logger");
+var import_redis2 = require("@tradejs/infra/redis");
+var import_cli2 = require("@tradejs/node/cli");
+var import_backtest = require("@tradejs/node/backtest");
+var import_connectors2 = require("@tradejs/node/connectors");
+
+// src/lib/runtimeParity.ts
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
+var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
+var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
+var buildPriceDeltaPct = (leftPrice, rightPrice) => {
+  if (leftPrice == null || rightPrice == null || !Number.isFinite(leftPrice) || !Number.isFinite(rightPrice) || leftPrice === 0) {
+    return null;
+  }
+  return Math.abs((rightPrice - leftPrice) / leftPrice * 100);
+};
+var extractBacktestEntryParityEntries = (orderLog) => {
+  if (!Array.isArray(orderLog)) {
+    return [];
+  }
+  return orderLog.filter(
+    (item) => (item.type === "OPEN_LONG" || item.type === "OPEN_SHORT") && item.signal && typeof item.signal.strategy === "string" && typeof item.signal.symbol === "string" && (item.signal.direction === "LONG" || item.signal.direction === "SHORT")
+  ).map((item, index) => {
+    const signal = item.signal;
+    const timestamp = typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : item.timestamp;
+    return {
+      id: typeof signal.signalId === "string" && signal.signalId.trim() ? signal.signalId : `backtest-${index}-${timestamp}`,
+      source: "backtest",
+      strategy: signal.strategy,
+      symbol: signal.symbol,
+      direction: signal.direction,
+      timestamp,
+      price: toFiniteNumberOrNull(item.price),
+      signalId: typeof signal.signalId === "string" ? signal.signalId : void 0
+    };
+  }).sort((left, right) => left.timestamp - right.timestamp);
+};
+var extractRuntimeParityEntries = (trades) => trades.filter(
+  (trade) => typeof trade.strategy === "string" && typeof trade.symbol === "string" && (trade.direction === "LONG" || trade.direction === "SHORT") && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp)
+).map((trade) => ({
+  id: trade.orderId,
+  source: "runtime",
+  strategy: trade.strategy,
+  symbol: trade.symbol,
+  direction: trade.direction,
+  timestamp: trade.entryTimestamp,
+  price: toFiniteNumberOrNull(trade.entryPrice),
+  orderId: trade.orderId,
+  signalId: typeof trade.signalId === "string" ? trade.signalId : void 0
+})).sort((left, right) => left.timestamp - right.timestamp);
+var findRuntimeDuplicateGroups = (entries) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.source !== "runtime") {
+      continue;
+    }
+    const key = toRuntimeDuplicateKey(entry);
+    const bucket = groups.get(key) ?? [];
+    bucket.push(entry);
+    groups.set(key, bucket);
+  }
+  return [...groups.entries()].filter(([, group]) => group.length > 1).map(([key, group]) => {
+    const sortedGroup = [...group].sort(sortTradeParityEntries);
+    const first = sortedGroup[0];
+    return {
+      key,
+      strategy: first.strategy,
+      symbol: first.symbol,
+      direction: first.direction,
+      timestamp: first.timestamp,
+      entries: sortedGroup
+    };
+  }).sort(
+    (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction)
+  );
+};
+var dedupeRuntimeParityEntries = (entries) => {
+  const duplicateGroups = findRuntimeDuplicateGroups(entries);
+  const duplicateEntriesSet = /* @__PURE__ */ new Set();
+  for (const group of duplicateGroups) {
+    for (const duplicate of group.entries.slice(1)) {
+      duplicateEntriesSet.add(duplicate);
+    }
+  }
+  const dedupedEntries = entries.filter((entry) => !duplicateEntriesSet.has(entry)).sort(sortTradeParityEntries);
+  const duplicateEntries = duplicateGroups.flatMap((group) => group.entries.slice(1)).sort(sortTradeParityEntries);
+  return {
+    entries: dedupedEntries,
+    duplicateGroups,
+    duplicateEntries
+  };
+};
+var compareTradeParityEntries = ({
+  runtimeEntries,
+  backtestEntries,
+  toleranceMs
+}) => {
+  const matched = [];
+  const runtimeOnly = [];
+  const backtestOnly = [];
+  const groupedRuntime = /* @__PURE__ */ new Map();
+  const groupedBacktest = /* @__PURE__ */ new Map();
+  for (const entry of runtimeEntries) {
+    const key = toGroupKey(entry);
+    const bucket = groupedRuntime.get(key) ?? [];
+    bucket.push(entry);
+    groupedRuntime.set(key, bucket);
+  }
+  for (const entry of backtestEntries) {
+    const key = toGroupKey(entry);
+    const bucket = groupedBacktest.get(key) ?? [];
+    bucket.push(entry);
+    groupedBacktest.set(key, bucket);
+  }
+  const groupKeys = /* @__PURE__ */ new Set([
+    ...groupedRuntime.keys(),
+    ...groupedBacktest.keys()
+  ]);
+  for (const key of groupKeys) {
+    const runtimeGroup = [...groupedRuntime.get(key) ?? []].sort(
+      (left, right) => left.timestamp - right.timestamp
+    );
+    const backtestGroup = [...groupedBacktest.get(key) ?? []].sort(
+      (left, right) => left.timestamp - right.timestamp
+    );
+    const unmatchedBacktest = backtestGroup.map((entry) => ({
+      entry,
+      used: false
+    }));
+    for (const runtimeEntry of runtimeGroup) {
+      let bestIndex = -1;
+      let bestDiff = Number.POSITIVE_INFINITY;
+      for (let index = 0; index < unmatchedBacktest.length; index += 1) {
+        const candidate = unmatchedBacktest[index];
+        if (candidate.used) {
+          continue;
+        }
+        const diff = Math.abs(
+          candidate.entry.timestamp - runtimeEntry.timestamp
+        );
+        if (diff > toleranceMs || diff >= bestDiff) {
+          continue;
+        }
+        bestIndex = index;
+        bestDiff = diff;
+      }
+      if (bestIndex < 0) {
+        runtimeOnly.push(runtimeEntry);
+        continue;
+      }
+      unmatchedBacktest[bestIndex].used = true;
+      const backtestEntry = unmatchedBacktest[bestIndex].entry;
+      matched.push({
+        runtime: runtimeEntry,
+        backtest: backtestEntry,
+        timestampDiffMs: bestDiff,
+        priceDeltaPct: buildPriceDeltaPct(
+          runtimeEntry.price,
+          backtestEntry.price
+        )
+      });
+    }
+    for (const candidate of unmatchedBacktest) {
+      if (!candidate.used) {
+        backtestOnly.push(candidate.entry);
+      }
+    }
+  }
+  matched.sort(
+    (left, right) => left.runtime.timestamp - right.runtime.timestamp
+  );
+  runtimeOnly.sort((left, right) => left.timestamp - right.timestamp);
+  backtestOnly.sort((left, right) => left.timestamp - right.timestamp);
+  return {
+    matched,
+    runtimeOnly,
+    backtestOnly
+  };
+};
+var summarizeMatchedParity = (matched) => {
+  if (!matched.length) {
+    return {
+      avgPriceDeltaPct: null,
+      maxPriceDeltaPct: null,
+      avgTimestampDiffMs: null,
+      maxTimestampDiffMs: null
+    };
+  }
+  const priceDeltas = matched.map((item) => item.priceDeltaPct).filter(
+    (value) => value != null && Number.isFinite(value)
+  );
+  const timestampDiffs = matched.map((item) => item.timestampDiffMs).filter((value) => Number.isFinite(value));
+  const average = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
+  const maximum = (values) => values.length ? Math.max(...values) : null;
+  return {
+    avgPriceDeltaPct: average(priceDeltas),
+    maxPriceDeltaPct: maximum(priceDeltas),
+    avgTimestampDiffMs: average(timestampDiffs),
+    maxTimestampDiffMs: maximum(timestampDiffs)
+  };
+};
+
+// src/lib/cliArgs.ts
+var normalizeCliArgv = (argv, legacyFlagMap) => argv.map((arg) => {
+  const [flag, ...rest] = String(arg).split("=");
+  const normalizedFlag = legacyFlagMap[flag];
+  if (!normalizedFlag) {
+    return arg;
+  }
+  if (!rest.length) {
+    return normalizedFlag;
+  }
+  return `${normalizedFlag}=${rest.join("=")}`;
+});
+
+// src/lib/runtimeSignalsLoader.ts
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var isSignalRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
+};
+var isRuntimeSignalEvaluationRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
+};
+var sortByTimestamp = (records) => [...records].sort((left, right) => left.timestamp - right.timestamp);
+var loadRuntimeSignals = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalBuckets(userName));
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const seen = /* @__PURE__ */ new Set();
+  const payloads = await Promise.all(
+    refs.map(async (ref) => {
+      const dedupeKey = `${ref.symbol}:${ref.signalId}`;
+      if (seen.has(dedupeKey)) {
+        return null;
+      }
+      seen.add(dedupeKey);
+      const signal = await (0, import_redis.getData)(
+        import_redis.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var loadRuntimeSignalEvaluations = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(
+    import_redis.redisKeys.runtimeSignalEvaluationBuckets(userName)
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    deduped.set(evaluation.evaluationId, evaluation);
+  }
+  return sortByTimestamp([...deduped.values()]);
+};
+
+// src/lib/telegramReports.ts
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  return chunks.length;
+};
+
+// src/lib/timeWindow.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var toEpochMs = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed < 1e12 ? Math.trunc(parsed * 1e3) : Math.trunc(parsed);
+};
+var toPositiveNumber = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+};
+var resolveTimeWindow = ({
+  days,
+  startTime,
+  endTime,
+  nowMs = Date.now(),
+  defaultStartMs,
+  defaultEndMs
+}) => {
+  const explicitStart = toEpochMs(startTime);
+  const explicitEnd = toEpochMs(endTime);
+  if (explicitStart != null || explicitEnd != null) {
+    const resolvedEnd2 = explicitEnd ?? defaultEndMs ?? nowMs;
+    const resolvedStart = explicitStart ?? defaultStartMs;
+    if (resolvedStart >= resolvedEnd2) {
+      throw new Error(
+        `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
+      );
+    }
+    return {
+      start: resolvedStart,
+      end: resolvedEnd2,
+      source: "explicit"
+    };
+  }
+  const resolvedDays = toPositiveNumber(days);
+  if (resolvedDays != null) {
+    const resolvedEnd2 = defaultEndMs ?? nowMs;
+    const resolvedStart = resolvedEnd2 - resolvedDays * ONE_DAY_MS;
+    if (resolvedStart >= resolvedEnd2) {
+      throw new Error(
+        `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
+      );
+    }
+    return {
+      start: Math.trunc(resolvedStart),
+      end: Math.trunc(resolvedEnd2),
+      source: "days"
+    };
+  }
+  const resolvedEnd = defaultEndMs ?? nowMs;
+  if (defaultStartMs >= resolvedEnd) {
+    throw new Error(
+      `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
+    );
+  }
+  return {
+    start: Math.trunc(defaultStartMs),
+    end: Math.trunc(resolvedEnd),
+    source: "default"
+  };
+};
+
+// 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",
+  "Replay with runtime AI/ML gates enabled when configured. This may call external AI providers and ML inference.",
+  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 REPLAY_ENV = flags.runtimeGates ? "PARITY" : "BACKTEST";
+var formatDuration = (startedAt) => {
+  const seconds = Math.max(0, (Date.now() - startedAt) / 1e3);
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const restSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${restSeconds}s`;
+};
+var BACKTEST_ONLY_CLASSIFICATIONS = [
+  "gated_out",
+  "order_failed",
+  "core_skipped",
+  "not_evaluated",
+  "true_mismatch"
+];
+var RUNTIME_ONLY_CLASSIFICATIONS = [
+  "gated_out",
+  "order_failed",
+  "core_skipped",
+  "backtest_drift",
+  "not_evaluated",
+  "true_mismatch"
+];
+var parseSymbolsFromCLI = (symbols = "") => symbols.split(",").map((symbol) => symbol.trim().toUpperCase()).filter(Boolean).map((symbol) => symbol.endsWith("USDT") ? symbol : `${symbol}USDT`);
+var toTargetKey = (target) => `${target.strategy}::${target.symbol}`;
+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 normalizeSignalOrderStatus = (value) => {
+  if (value === "completed" || value === "failed" || value === "skipped" || value === "canceled") {
+    return value;
+  }
+  return "unknown";
+};
+var isRuntimeTradeRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
+};
+var resolveParityConnectorName = async (value) => {
+  const connectorName = await (0, import_connectors2.resolveConnectorName)(value, projectRoot);
+  if (connectorName) {
+    return connectorName;
+  }
+  import_logger.logger.warn(
+    'Unknown connector "%s". Fallback to %s.',
+    String(value || "").trim() || String(value),
+    import_connectors2.DEFAULT_CONNECTOR_NAME
+  );
+  return import_connectors2.DEFAULT_CONNECTOR_NAME;
+};
+var loadRuntimeTrades = async (userName) => {
+  const keys = await (0, import_redis2.getKeys)(import_redis2.redisKeys.runtimeTrades(userName));
+  const trades = await Promise.all(keys.map((key) => (0, import_redis2.getData)(key, null)));
+  return trades.filter(isRuntimeTradeRecord).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) {
+    return null;
+  }
+  const [users, keyUserName, strategiesKey, strategyName, configKey] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || configKey !== "config" || !strategyName) {
+    return null;
+  }
+  return strategyName;
+};
+var loadConfiguredStrategyNames = async (userName) => {
+  const keys = await (0, import_redis2.getKeys)(`${import_redis2.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => key.endsWith(":config")).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
+};
+var loadStrategyResultSymbols = async ({
+  userName,
+  strategy
+}) => {
+  const results = await (0, import_redis2.getData)(
+    import_redis2.redisKeys.strategyResults(userName, strategy),
+    {}
+  );
+  return Object.keys(results ?? {}).sort(
+    (left, right) => left.localeCompare(right)
+  );
+};
+var addReplayTarget = (targets, target, source) => {
+  const key = toTargetKey(target);
+  const existing = targets.get(key);
+  if (existing) {
+    if (!existing.sources.includes(source)) {
+      existing.sources.push(source);
+    }
+    return;
+  }
+  targets.set(key, {
+    strategy: target.strategy,
+    symbol: target.symbol,
+    sources: [source]
+  });
+};
+var countReplayTargetSources = (targets) => ({
+  runtime: targets.filter((target) => target.sources.includes("runtime")).length,
+  connectorUniverse: targets.filter(
+    (target) => target.sources.includes("connectorUniverse")
+  ).length,
+  explicitTickers: targets.filter(
+    (target) => target.sources.includes("explicitTickers")
+  ).length,
+  strategyResults: targets.filter(
+    (target) => target.sources.includes("strategyResults")
+  ).length
+});
+var buildReplayTargets = async ({
+  userName,
+  runtimeTrades,
+  connectorSymbols,
+  strategyFilter,
+  explicitSymbols,
+  includeConnectorUniverse
+}) => {
+  const targets = /* @__PURE__ */ new Map();
+  let configuredStrategies = (await loadConfiguredStrategyNames(userName)).filter((strategy) => !strategyFilter || strategy === strategyFilter);
+  if (strategyFilter && !configuredStrategies.some((strategy) => strategy === strategyFilter)) {
+    configuredStrategies = [strategyFilter];
+  }
+  const explicitSymbolSet = explicitSymbols.length ? new Set(explicitSymbols) : null;
+  for (const trade of runtimeTrades) {
+    if (strategyFilter && trade.strategy !== strategyFilter) {
+      continue;
+    }
+    if (explicitSymbolSet && !explicitSymbolSet.has(trade.symbol)) {
+      continue;
+    }
+    addReplayTarget(
+      targets,
+      { strategy: trade.strategy, symbol: trade.symbol },
+      "runtime"
+    );
+  }
+  if (explicitSymbols.length || includeConnectorUniverse) {
+    const universeSymbols = explicitSymbols.length ? explicitSymbols : connectorSymbols;
+    const universeSource = explicitSymbols.length ? "explicitTickers" : "connectorUniverse";
+    for (const strategy of configuredStrategies) {
+      for (const symbol of universeSymbols) {
+        addReplayTarget(targets, { strategy, symbol }, universeSource);
+      }
+    }
+  }
+  const strategySymbolsEntries = await Promise.all(
+    configuredStrategies.map(
+      async (strategy) => [
+        strategy,
+        await loadStrategyResultSymbols({ userName, strategy })
+      ]
+    )
+  );
+  for (const [strategy, symbols] of strategySymbolsEntries) {
+    for (const symbol of symbols) {
+      if (explicitSymbolSet && !explicitSymbolSet.has(symbol)) {
+        continue;
+      }
+      addReplayTarget(targets, { strategy, symbol }, "strategyResults");
+    }
+  }
+  return [...targets.values()].sort(
+    (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol)
+  );
+};
+var createConnector = async ({
+  userName,
+  connectorName
+}) => {
+  const connectorFactory = await (0, import_connectors2.getConnectorCreatorByName)(
+    connectorName,
+    projectRoot
+  );
+  if (!connectorFactory) {
+    throw new Error(`Connector "${connectorName}" is not registered`);
+  }
+  return await connectorFactory({ userName });
+};
+var buildReplayAiAnalyses = ({
+  runtimeTrades,
+  runtimeSignalEvaluations,
+  strategy,
+  symbol,
+  toleranceMs
+}) => {
+  const snapshots = [
+    ...runtimeTrades.filter(
+      (trade) => trade.strategy === strategy && trade.symbol === symbol && 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.strategy === strategy && evaluation.symbol === symbol && 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 buildReplayConfig = async ({
+  userName,
+  strategy,
+  symbol,
+  runtimeTrades,
+  runtimeSignalEvaluations,
+  toleranceMs
+}) => {
+  const [userConfig, strategyResults] = await Promise.all([
+    (0, import_redis2.getData)(import_redis2.redisKeys.strategyConfig(userName, strategy), {}),
+    (0, import_redis2.getData)(import_redis2.redisKeys.strategyResults(userName, strategy), {})
+  ]);
+  const typedResults = strategyResults ?? {};
+  const symbolResult = typedResults?.[symbol];
+  const symbolConfig = symbolResult && symbolResult.config && typeof symbolResult.config === "object" ? symbolResult.config : {};
+  const aiReplayAnalyses = buildReplayAiAnalyses({
+    runtimeTrades,
+    runtimeSignalEvaluations,
+    strategy,
+    symbol,
+    toleranceMs
+  });
+  return {
+    ...userConfig,
+    ...symbolConfig,
+    ENV: REPLAY_ENV,
+    MAKE_ORDERS: true,
+    INTERVAL: interval,
+    RECORD_RUNTIME_TRADES: false,
+    ...aiReplayAnalyses.length ? { AI_REPLAY_ANALYSES: 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_chalk.default.gray(
+      `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time.formatUnix)(preloadStart)} -> ${(0, import_time.formatUnix)(preloadEnd)}`
+    )
+  );
+  await (0, import_cli2.update)(connector, interval, symbols, void 0, {
+    connectorLabel: connectorName,
+    preloadStart,
+    preloadEnd
+  });
+  const [binanceFactory, coinbaseFactory] = await Promise.all([
+    (0, import_connectors2.getConnectorCreatorByName)(import_connectors.ConnectorNames.Binance, projectRoot),
+    (0, import_connectors2.getConnectorCreatorByName)(import_connectors.ConnectorNames.Coinbase, projectRoot)
+  ]);
+  if (binanceFactory) {
+    const binanceConnector = await binanceFactory({
+      userName
+    });
+    await (0, import_cli2.update)(binanceConnector, interval, ["BTCUSDT"], void 0, {
+      connectorLabel: import_connectors.ConnectorNames.Binance,
+      preloadStart,
+      preloadEnd
+    });
+  } else {
+    import_logger.logger.warn(
+      "Binance connector is unavailable. BTC reference replay may drift."
+    );
+  }
+  if (coinbaseFactory) {
+    const coinbaseConnector = await coinbaseFactory({
+      userName
+    });
+    await (0, import_cli2.update)(coinbaseConnector, interval, ["BTCUSDT"], void 0, {
+      connectorLabel: import_connectors.ConnectorNames.Coinbase,
+      preloadStart,
+      preloadEnd
+    });
+  } else {
+    import_logger.logger.warn(
+      "Coinbase connector is unavailable. BTC reference replay may drift."
+    );
+  }
+  console.log(
+    import_chalk.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
+  );
+};
+var formatPercent = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${value.toFixed(2)}%`;
+var formatMinutes = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${(value / 6e4).toFixed(2)}m`;
+var formatEntryLabel = (entry) => `${entry.strategy} ${entry.symbol} ${entry.direction} ${(0, import_time.formatUnix)(entry.timestamp)}`;
+var printRuntimeDuplicateDetails = (groups) => {
+  if (!groups.length) {
+    return;
+  }
+  console.log("");
+  console.log(import_chalk.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`);
+  }
+};
+var findNearestRuntimeSignal = ({
+  entry,
+  runtimeSignals,
+  toleranceMs
+}) => {
+  let bestSignal = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const signal of runtimeSignals) {
+    if (signal.strategy !== entry.strategy || signal.symbol !== entry.symbol || signal.direction !== entry.direction) {
+      continue;
+    }
+    const diff = Math.abs(signal.timestamp - entry.timestamp);
+    if (diff > toleranceMs || diff >= bestDiff) {
+      continue;
+    }
+    bestSignal = signal;
+    bestDiff = diff;
+  }
+  return bestSignal ? {
+    signal: bestSignal,
+    timestampDiffMs: bestDiff
+  } : null;
+};
+var findNearestRuntimeSignalEvaluation = ({
+  entry,
+  runtimeSignalEvaluations,
+  toleranceMs
+}) => {
+  let bestEvaluation = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const evaluation of runtimeSignalEvaluations) {
+    if (evaluation.strategy !== entry.strategy || evaluation.symbol !== entry.symbol) {
+      continue;
+    }
+    const diff = Math.abs(evaluation.timestamp - entry.timestamp);
+    if (diff > toleranceMs || diff >= bestDiff) {
+      continue;
+    }
+    bestEvaluation = evaluation;
+    bestDiff = diff;
+  }
+  return bestEvaluation ? {
+    evaluation: bestEvaluation,
+    timestampDiffMs: bestDiff
+  } : null;
+};
+var findNearestBacktestEntryForRuntimeOnly = ({
+  entry,
+  backtestEntries
+}) => {
+  let bestEntry = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const backtestEntry of backtestEntries) {
+    if (backtestEntry.strategy !== entry.strategy || backtestEntry.symbol !== entry.symbol || backtestEntry.direction !== entry.direction) {
+      continue;
+    }
+    const diff = Math.abs(backtestEntry.timestamp - entry.timestamp);
+    if (diff >= bestDiff) {
+      continue;
+    }
+    bestEntry = backtestEntry;
+    bestDiff = diff;
+  }
+  return bestEntry ? {
+    entry: bestEntry,
+    timestampDiffMs: bestDiff
+  } : null;
+};
+var buildSignalClassificationReason = ({
+  signal,
+  orderStatus,
+  classification
+}) => {
+  const skipReason = typeof signal.orderSkipReason === "string" ? signal.orderSkipReason.trim() : "";
+  if (skipReason) {
+    return skipReason;
+  }
+  if (classification === "gated_out" && signal.ml?.passed === false) {
+    return `ml_probability=${signal.ml.probability.toFixed(4)} threshold=${signal.ml.threshold.toFixed(4)}`;
+  }
+  if (orderStatus === "completed") {
+    return "completed_signal_without_runtime_trade";
+  }
+  if (orderStatus !== "unknown") {
+    return `orderStatus=${orderStatus}`;
+  }
+  return "runtime_signal_without_completed_trade";
+};
+var buildEvaluationClassification = ({
+  entry,
+  evaluation
+}) => {
+  if (evaluation.status === "skip") {
+    return {
+      classification: "core_skipped",
+      reason: evaluation.reason || "NO_SIGNAL"
+    };
+  }
+  if (evaluation.status === "error") {
+    return {
+      classification: "true_mismatch",
+      reason: evaluation.reason || "runtime_evaluation_error"
+    };
+  }
+  if (evaluation.direction && evaluation.direction !== entry.direction) {
+    return {
+      classification: "core_skipped",
+      reason: `runtime_signal_direction=${evaluation.direction}`
+    };
+  }
+  const orderStatus = normalizeSignalOrderStatus(evaluation.orderStatus);
+  if (orderStatus === "failed") {
+    return {
+      classification: "order_failed",
+      reason: evaluation.reason || "orderStatus=failed"
+    };
+  }
+  if (orderStatus === "skipped" || orderStatus === "canceled" || typeof evaluation.orderSkipReason === "string" && evaluation.orderSkipReason.trim()) {
+    return {
+      classification: "gated_out",
+      reason: evaluation.orderSkipReason || evaluation.reason || `orderStatus=${orderStatus}`
+    };
+  }
+  if (orderStatus === "completed") {
+    return {
+      classification: "true_mismatch",
+      reason: "completed_signal_without_runtime_trade"
+    };
+  }
+  return {
+    classification: "true_mismatch",
+    reason: evaluation.reason || "runtime_signal_without_completed_trade"
+  };
+};
+var buildRuntimeOnlyEvaluationClassification = ({
+  entry,
+  evaluation
+}) => {
+  if (evaluation.status === "skip") {
+    return {
+      classification: "core_skipped",
+      reason: evaluation.reason || "NO_SIGNAL"
+    };
+  }
+  if (evaluation.status === "error") {
+    return {
+      classification: "true_mismatch",
+      reason: evaluation.reason || "replay_evaluation_error"
+    };
+  }
+  if (evaluation.direction && evaluation.direction !== entry.direction) {
+    return {
+      classification: "true_mismatch",
+      reason: `replay_signal_direction=${evaluation.direction}`
+    };
+  }
+  const orderStatus = normalizeSignalOrderStatus(evaluation.orderStatus);
+  if (orderStatus === "failed") {
+    return {
+      classification: "order_failed",
+      reason: evaluation.reason || "orderStatus=failed"
+    };
+  }
+  if (orderStatus === "skipped" || orderStatus === "canceled" || typeof evaluation.orderSkipReason === "string" && evaluation.orderSkipReason.trim()) {
+    return {
+      classification: "gated_out",
+      reason: evaluation.orderSkipReason || evaluation.reason || `orderStatus=${orderStatus}`
+    };
+  }
+  if (orderStatus === "completed") {
+    return {
+      classification: "true_mismatch",
+      reason: "completed_replay_signal_without_backtest_trade"
+    };
+  }
+  return {
+    classification: "true_mismatch",
+    reason: evaluation.reason || "runtime_trade_without_replay_trade"
+  };
+};
+var classifyBacktestOnlyEntries = ({
+  entries,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  toleranceMs
+}) => entries.map((entry) => {
+  const nearestSignal = findNearestRuntimeSignal({
+    entry,
+    runtimeSignals,
+    toleranceMs
+  });
+  if (!nearestSignal) {
+    const nearestEvaluation = findNearestRuntimeSignalEvaluation({
+      entry,
+      runtimeSignalEvaluations,
+      toleranceMs
+    });
+    if (nearestEvaluation) {
+      const evaluationClassification = buildEvaluationClassification({
+        entry,
+        evaluation: nearestEvaluation.evaluation
+      });
+      return {
+        entry,
+        ...evaluationClassification,
+        evaluation: nearestEvaluation.evaluation,
+        evaluationTimestampDiffMs: nearestEvaluation.timestampDiffMs
+      };
+    }
+    return {
+      entry,
+      classification: "not_evaluated",
+      reason: "no_runtime_evaluation"
+    };
+  }
+  const orderStatus = normalizeSignalOrderStatus(
+    nearestSignal.signal.orderStatus
+  );
+  let classification;
+  if (orderStatus === "failed") {
+    classification = "order_failed";
+  } else if (orderStatus === "skipped" || orderStatus === "canceled" || nearestSignal.signal.ml?.passed === false || typeof nearestSignal.signal.orderSkipReason === "string" && nearestSignal.signal.orderSkipReason.trim()) {
+    classification = "gated_out";
+  } else {
+    classification = "true_mismatch";
+  }
+  return {
+    entry,
+    classification,
+    reason: buildSignalClassificationReason({
+      signal: nearestSignal.signal,
+      orderStatus,
+      classification
+    }),
+    signal: nearestSignal.signal,
+    signalTimestampDiffMs: nearestSignal.timestampDiffMs
+  };
+});
+var classifyRuntimeOnlyEntries = ({
+  entries,
+  replaySignalEvaluations,
+  backtestEntries,
+  toleranceMs
+}) => entries.map((entry) => {
+  const nearestBacktestEntry = findNearestBacktestEntryForRuntimeOnly({
+    entry,
+    backtestEntries
+  });
+  if (nearestBacktestEntry && nearestBacktestEntry.timestampDiffMs > toleranceMs) {
+    return {
+      entry,
+      classification: "backtest_drift",
+      reason: `nearest_backtest_entry_drift=${formatMinutes(nearestBacktestEntry.timestampDiffMs)}`,
+      nearestBacktestEntry: nearestBacktestEntry.entry,
+      nearestBacktestEntryTimestampDiffMs: nearestBacktestEntry.timestampDiffMs
+    };
+  }
+  const nearestEvaluation = findNearestRuntimeSignalEvaluation({
+    entry,
+    runtimeSignalEvaluations: replaySignalEvaluations,
+    toleranceMs
+  });
+  if (!nearestEvaluation) {
+    return {
+      entry,
+      classification: "not_evaluated",
+      reason: "no_replay_evaluation"
+    };
+  }
+  return {
+    entry,
+    ...buildRuntimeOnlyEvaluationClassification({
+      entry,
+      evaluation: nearestEvaluation.evaluation
+    }),
+    evaluation: nearestEvaluation.evaluation,
+    evaluationTimestampDiffMs: nearestEvaluation.timestampDiffMs
+  };
+});
+var summarizeBacktestOnlyClassifications = (classifiedEntries) => {
+  const counts = new Map(
+    BACKTEST_ONLY_CLASSIFICATIONS.map((classification) => [classification, 0])
+  );
+  for (const item of classifiedEntries) {
+    counts.set(item.classification, (counts.get(item.classification) ?? 0) + 1);
+  }
+  return BACKTEST_ONLY_CLASSIFICATIONS.map(
+    (classification) => `${classification}=${counts.get(classification) ?? 0}`
+  ).join(", ");
+};
+var summarizeRuntimeOnlyClassifications = (classifiedEntries) => {
+  const counts = new Map(
+    RUNTIME_ONLY_CLASSIFICATIONS.map((classification) => [classification, 0])
+  );
+  for (const item of classifiedEntries) {
+    counts.set(item.classification, (counts.get(item.classification) ?? 0) + 1);
+  }
+  return RUNTIME_ONLY_CLASSIFICATIONS.map(
+    (classification) => `${classification}=${counts.get(classification) ?? 0}`
+  ).join(", ");
+};
+var printClassifiedBacktestOnlyDetails = (classifiedEntries) => {
+  if (!classifiedEntries.length) {
+    return;
+  }
+  console.log("");
+  console.log(import_chalk.default.yellow("Backtest only"));
+  for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
+    const evidenceSuffix = item.signal ? ` signalId=${item.signal.signalId} signalDrift=${formatMinutes(item.signalTimestampDiffMs ?? null)}` : item.evaluation ? ` evaluationId=${item.evaluation.evaluationId} evaluationDrift=${formatMinutes(item.evaluationTimestampDiffMs ?? null)}` : "";
+    const price = item.entry.price == null ? "n/a" : item.entry.price.toFixed(6);
+    console.log(
+      `- [${item.classification}] ${formatEntryLabel(item.entry)} price=${price} id=${item.entry.id} reason=${item.reason}${evidenceSuffix}`
+    );
+  }
+  if (classifiedEntries.length > DETAIL_LIMIT) {
+    console.log(`- ... ${classifiedEntries.length - DETAIL_LIMIT} more`);
+  }
+};
+var printClassifiedRuntimeOnlyDetails = (classifiedEntries) => {
+  if (!classifiedEntries.length) {
+    return;
+  }
+  console.log("");
+  console.log(import_chalk.default.yellow("Runtime only"));
+  for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
+    const evidenceSuffix = item.nearestBacktestEntry ? ` nearestBacktestId=${item.nearestBacktestEntry.id} backtestDrift=${formatMinutes(item.nearestBacktestEntryTimestampDiffMs ?? null)}` : item.evaluation ? ` replayEvaluationId=${item.evaluation.evaluationId} replayDrift=${formatMinutes(item.evaluationTimestampDiffMs ?? null)} status=${item.evaluation.status}` : "";
+    const price = item.entry.price == null ? "n/a" : item.entry.price.toFixed(6);
+    console.log(
+      `- [${item.classification}] ${formatEntryLabel(item.entry)} price=${price} id=${item.entry.id} reason=${item.reason}${evidenceSuffix}`
+    );
+  }
+  if (classifiedEntries.length > DETAIL_LIMIT) {
+    console.log(`- ... ${classifiedEntries.length - DETAIL_LIMIT} more`);
+  }
+};
+var summarizeByStrategy = ({
+  targets,
+  successfulTargetKeys,
+  replayErrors,
+  runtimeEntries,
+  runtimeDuplicateEntries,
+  backtestEntries,
+  matchedEntries,
+  runtimeOnlyEntries,
+  backtestOnlyEntries
+}) => {
+  const rows = /* @__PURE__ */ new Map();
+  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;
+  }
+  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)
+  );
+};
+var buildRuntimeParityMessage = ({
+  window,
+  connectorName,
+  replayEnv,
+  runtimeGatesEnabled,
+  toleranceBars,
+  toleranceMs,
+  replayTargetsCount,
+  comparedTargetsCount,
+  replayErrors,
+  sourceCounts,
+  rawRuntimeEntriesCount,
+  runtimeEntriesCount,
+  runtimeDuplicateEntriesCount,
+  backtestEntriesCount,
+  matchedCount,
+  runtimeOnlyCount,
+  backtestOnlyCount,
+  matchedSummary,
+  classifiedRuntimeOnly,
+  classifiedBacktestOnly,
+  runtimeSignalEvaluationsCount,
+  strategyRows,
+  runtimeGateWarningCounts
+}) => {
+  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>`
+  );
+  lines.push("");
+  lines.push(`\u{1F50C} Connector: <b>${escapeHtml(connectorName)}</b>`);
+  lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml(replayEnv)}</b>`);
+  lines.push(
+    `\u{1F6A6} Runtime gates: <b>${runtimeGatesEnabled ? "\u2705 enabled" : "\u26D4 disabled"}</b>`
+  );
+  lines.push(
+    `\u{1F3AF} Tolerance: <b>${toleranceBars} bar(s) / ${(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>`
+  );
+  lines.push(
+    `\u2022 Sources: runtime=<b>${sourceCounts.runtime}</b>, universe=<b>${sourceCounts.connectorUniverse}</b>, explicit=<b>${sourceCounts.explicitTickers}</b>, results=<b>${sourceCounts.strategyResults}</b>`
+  );
+  lines.push("");
+  lines.push("\u{1F4C8} <b>Entries</b>");
+  lines.push(
+    `\u2022 Runtime: <b>${rawRuntimeEntriesCount}</b> (deduped <b>${runtimeEntriesCount}</b>, dup <b>${runtimeDuplicateEntriesCount}</b>)`
+  );
+  lines.push(`\u2022 Backtest: <b>${backtestEntriesCount}</b>`);
+  lines.push(`\u2022 Matched: <b>${matchedCount}</b>`);
+  lines.push(
+    `\u2022 Runtime only: <b>${runtimeOnlyCount}</b> / Backtest only: <b>${backtestOnlyCount}</b>`
+  );
+  lines.push(
+    `\u2022 Deltas: price <b>${escapeHtml(formatPercent(matchedSummary.avgPriceDeltaPct))} / ${escapeHtml(formatPercent(matchedSummary.maxPriceDeltaPct))}</b>, drift <b>${escapeHtml(formatMinutes(matchedSummary.avgTimestampDiffMs))} / ${escapeHtml(formatMinutes(matchedSummary.maxTimestampDiffMs))}</b>`
+  );
+  if (classifiedRuntimeOnly.length) {
+    lines.push(
+      `\u2022 Runtime-only classes: <code>${escapeHtml(summarizeRuntimeOnlyClassifications(classifiedRuntimeOnly))}</code>`
+    );
+  }
+  if (classifiedBacktestOnly.length) {
+    lines.push(
+      `\u2022 Backtest-only classes: <code>${escapeHtml(summarizeBacktestOnlyClassifications(classifiedBacktestOnly))}</code>`
+    );
+  }
+  if (runtimeSignalEvaluationsCount) {
+    lines.push(
+      `\u2022 Runtime evaluations: <b>${runtimeSignalEvaluationsCount}</b>`
+    );
+  }
+  if (strategyRows.length) {
+    lines.push("");
+    lines.push("\u{1F4CA} <b>By strategy</b>");
+    for (const [strategy, row] of strategyRows) {
+      lines.push("");
+      lines.push(`<b>${escapeHtml(strategy)}</b>`);
+      lines.push(
+        `\u2022 targets=<b>${row.targets}</b>, compared=<b>${row.compared}</b>, errors=<b>${row.errors}</b>`
+      );
+      lines.push(
+        `\u2022 runtime=<b>${row.runtime}</b> (dup <b>${row.runtimeDuplicates}</b>), backtest=<b>${row.backtest}</b>, matched=<b>${row.matched}</b>`
+      );
+      lines.push(
+        `\u2022 runtimeOnly=<b>${row.runtimeOnly}</b>, backtestOnly=<b>${row.backtestOnly}</b>`
+      );
+    }
+  }
+  if (runtimeGateWarningCounts.size && !runtimeGatesEnabled) {
+    lines.push("");
+    lines.push("\u26A0\uFE0F <b>Warnings</b>");
+    for (const [strategy, count] of [
+      ...runtimeGateWarningCounts.entries()
+    ].sort(([left], [right]) => left.localeCompare(right))) {
+      lines.push(
+        `\u2022 <b>${escapeHtml(strategy)}</b>: AI/ML runtime gates configured on <b>${count}</b> target(s); BACKTEST replay covers core execution only.`
+      );
+    }
+  }
+  if (replayErrors.length) {
+    lines.push("");
+    lines.push("\u274C <b>Replay errors</b>");
+    for (const error of 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) {
+      lines.push(
+        `... <b>${replayErrors.length - TELEGRAM_DETAIL_LIMIT}</b> more`
+      );
+    }
+  }
+  return lines.join("\n");
+};
+var buildRuntimeParityNoTargetsMessage = ({
+  window,
+  connectorName,
+  replayEnv,
+  runtimeGatesEnabled,
+  userName
+}) => [
+  "\u{1F9EA} <b>TradeJS runtime parity</b>",
+  "",
+  "\u{1F552} <b>Window</b>",
+  `<b>${escapeHtml(formatMskDateTime(window.start))} - ${escapeHtml(formatMskDateTime(window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`,
+  "",
+  `\u{1F50C} Connector: <b>${escapeHtml(connectorName)}</b>`,
+  `\u{1F9EC} Replay env: <b>${escapeHtml(replayEnv)}</b>`,
+  `\u{1F6A6} Runtime gates: <b>${runtimeGatesEnabled ? "\u2705 enabled" : "\u26D4 disabled"}</b>`,
+  "",
+  `\u26A0\uFE0F No replay targets found for user <b>${escapeHtml(userName)}</b>.`
+].join("\n");
+var runtimeParity = async () => {
+  const window = resolveTimeWindow({
+    days: flags.days ?? DEFAULT_LOOKBACK_DAYS,
+    startTime: flags.startTime,
+    endTime: flags.endTime,
+    defaultStartMs: Date.now() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3,
+    defaultEndMs: Date.now()
+  });
+  const toleranceBars = Math.max(
+    0,
+    Number.parseInt(String(flags.toleranceBars ?? 1), 10) || 0
+  );
+  const toleranceMs = toleranceBars * 15 * 60 * 1e3;
+  const connectorName = await resolveParityConnectorName(flags.connector);
+  const requestedSymbols = parseSymbolsFromCLI(String(flags.tickers || ""));
+  const requestedSymbolSet = requestedSymbols.length ? new Set(requestedSymbols) : null;
+  let replayErrors = [];
+  try {
+    const parityConnector = await createConnector({
+      userName: flags.user,
+      connectorName
+    });
+    const [allRuntimeTrades, allRuntimeSignals, allRuntimeSignalEvaluations] = await Promise.all([
+      loadRuntimeTrades(flags.user),
+      loadRuntimeSignals(flags.user),
+      loadRuntimeSignalEvaluations(flags.user)
+    ]);
+    const runtimeTrades = allRuntimeTrades.filter(
+      (trade) => trade.entryTimestamp >= window.start && trade.entryTimestamp <= window.end && (!flags.strategy || trade.strategy === flags.strategy)
+    );
+    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 connectorSymbols = requestedSymbols.length ? requestedSymbols : await (0, import_cli2.getTickers)(parityConnector);
+    const replayTargets = await buildReplayTargets({
+      userName: flags.user,
+      runtimeTrades,
+      connectorSymbols,
+      strategyFilter: String(flags.strategy || "").trim() || void 0,
+      explicitSymbols: requestedSymbols,
+      includeConnectorUniverse: Boolean(flags.fullUniverse)
+    });
+    if (!replayTargets.length) {
+      console.log(
+        import_chalk.default.yellow(
+          `No replay targets found for ${flags.user} in ${(0, import_time.formatUnix)(window.start)} -> ${(0, import_time.formatUnix)(window.end)}.`
+        )
+      );
+      if (flags.notify) {
+        await sendTelegramReport(
+          buildRuntimeParityNoTargetsMessage({
+            window,
+            connectorName,
+            replayEnv: REPLAY_ENV,
+            runtimeGatesEnabled: Boolean(flags.runtimeGates),
+            userName: String(flags.user)
+          }),
+          { userName: flags.user }
+        );
+      }
+      return;
+    }
+    const sourceCounts = countReplayTargetSources(replayTargets);
+    const preloadStart = (0, import_time.getBacktestPreloadStart)(
+      window.start,
+      import_constants.BACKTEST_PRELOAD_DAYS
+    );
+    const replayStartedAt = Date.now();
+    const replaySymbolsCount = new Set(
+      replayTargets.map((target) => target.symbol)
+    ).size;
+    console.log(
+      import_chalk.default.gray(
+        `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
+      )
+    );
+    if (!flags.cacheOnly) {
+      await warmReplayHistory({
+        userName: flags.user,
+        connectorName,
+        targets: replayTargets,
+        preloadStart,
+        preloadEnd: window.end
+      });
+    }
+    const backtestEntries = [];
+    const replaySignalEvaluations = [];
+    const successfulTargetKeys = /* @__PURE__ */ new Set();
+    const runtimeGateWarningCounts = /* @__PURE__ */ new Map();
+    for (const [targetIndex, target] of replayTargets.entries()) {
+      const progressPosition = targetIndex + 1;
+      try {
+        const replayConfig = await buildReplayConfig({
+          userName: flags.user,
+          strategy: target.strategy,
+          symbol: target.symbol,
+          runtimeTrades,
+          runtimeSignalEvaluations,
+          toleranceMs
+        });
+        if (replayConfig.AI_ENABLED === true || replayConfig.ML_ENABLED === true) {
+          runtimeGateWarningCounts.set(
+            target.strategy,
+            (runtimeGateWarningCounts.get(target.strategy) ?? 0) + 1
+          );
+        }
+        const result = await (0, import_backtest.testing)({
+          userName: flags.user,
+          symbol: target.symbol,
+          options: {
+            start: window.start,
+            end: window.end
+          },
+          name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto.randomUUID)().slice(0, 8)}`,
+          testId: (0, import_node_crypto.randomUUID)().slice(0, 8),
+          testSuiteId: (0, import_node_crypto.randomUUID)().slice(0, 8),
+          strategyName: target.strategy,
+          strategyConfig: replayConfig,
+          connectorName,
+          timeoutMs: 12e4
+        });
+        backtestEntries.push(
+          ...extractBacktestEntryParityEntries(result?.inlineOrderLog)
+        );
+        replaySignalEvaluations.push(
+          ...result?.inlineReplaySignalEvaluations ?? []
+        );
+        successfulTargetKeys.add(toTargetKey(target));
+      } catch (error) {
+        replayErrors.push({
+          ...target,
+          message: error?.message || String(error)
+        });
+      }
+      if (progressPosition === 1 || progressPosition === replayTargets.length || progressPosition % 25 === 0) {
+        console.log(
+          import_chalk.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({
+      runtimeEntries,
+      backtestEntries,
+      toleranceMs
+    });
+    const classifiedBacktestOnly = classifyBacktestOnlyEntries({
+      entries: comparison.backtestOnly,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      toleranceMs
+    });
+    const classifiedRuntimeOnly = classifyRuntimeOnlyEntries({
+      entries: comparison.runtimeOnly,
+      replaySignalEvaluations,
+      backtestEntries,
+      toleranceMs
+    });
+    const summary = summarizeMatchedParity(comparison.matched);
+    console.log(import_chalk.default.cyan("TradeJS runtime parity"));
+    console.log(
+      `Window: ${(0, import_time.formatUnix)(window.start)} -> ${(0, import_time.formatUnix)(window.end)} (${window.source})`
+    );
+    console.log(`Connector: ${connectorName}`);
+    console.log(
+      `Replay env: ${REPLAY_ENV}${flags.runtimeGates ? " (runtime AI/ML gates enabled)" : " (core/backtest gates only)"}`
+    );
+    console.log(
+      `Tolerance: ${toleranceBars} bar(s) / ${(toleranceMs / 6e4).toFixed(0)}m`
+    );
+    console.log(
+      `Targets: ${replayTargets.length}, compared: ${successfulTargetKeys.size}, replayErrors: ${replayErrors.length}`
+    );
+    console.log(
+      `Target sources: runtime=${sourceCounts.runtime}, connectorUniverse=${sourceCounts.connectorUniverse}, explicitTickers=${sourceCounts.explicitTickers}, strategyResults=${sourceCounts.strategyResults}`
+    );
+    console.log("");
+    console.log(
+      `Runtime entries: ${rawRuntimeEntries.length} (deduped: ${runtimeEntries.length}, duplicates: ${runtimeDedupe.duplicateEntries.length}), backtest entries: ${backtestEntries.length}, matched: ${comparison.matched.length}, runtimeOnly: ${comparison.runtimeOnly.length}, backtestOnly: ${comparison.backtestOnly.length}`
+    );
+    console.log(
+      `Matched price delta avg/max: ${formatPercent(summary.avgPriceDeltaPct)} / ${formatPercent(summary.maxPriceDeltaPct)}`
+    );
+    console.log(
+      `Matched timestamp drift avg/max: ${formatMinutes(summary.avgTimestampDiffMs)} / ${formatMinutes(summary.maxTimestampDiffMs)}`
+    );
+    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
+    });
+    if (strategyRows.length) {
+      console.log("");
+      console.log(import_chalk.default.cyan("By strategy"));
+      for (const [strategy, row] of strategyRows) {
+        console.log(
+          `- ${strategy}: targets=${row.targets}, compared=${row.compared}, errors=${row.errors}, runtime=${row.runtime}, runtimeDuplicates=${row.runtimeDuplicates}, backtest=${row.backtest}, matched=${row.matched}, runtimeOnly=${row.runtimeOnly}, backtestOnly=${row.backtestOnly}`
+        );
+      }
+    }
+    if (runtimeGateWarningCounts.size && !flags.runtimeGates) {
+      console.log("");
+      console.log(import_chalk.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_chalk.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);
+      printClassifiedBacktestOnlyDetails(classifiedBacktestOnly);
+    }
+    if (flags.notify) {
+      await sendTelegramReport(
+        buildRuntimeParityMessage({
+          window,
+          connectorName,
+          replayEnv: REPLAY_ENV,
+          runtimeGatesEnabled: Boolean(flags.runtimeGates),
+          toleranceBars,
+          toleranceMs,
+          replayTargetsCount: replayTargets.length,
+          comparedTargetsCount: successfulTargetKeys.size,
+          replayErrors,
+          sourceCounts,
+          rawRuntimeEntriesCount: rawRuntimeEntries.length,
+          runtimeEntriesCount: runtimeEntries.length,
+          runtimeDuplicateEntriesCount: runtimeDedupe.duplicateEntries.length,
+          backtestEntriesCount: backtestEntries.length,
+          matchedCount: comparison.matched.length,
+          runtimeOnlyCount: comparison.runtimeOnly.length,
+          backtestOnlyCount: comparison.backtestOnly.length,
+          matchedSummary: summary,
+          classifiedRuntimeOnly,
+          classifiedBacktestOnly,
+          runtimeSignalEvaluationsCount: runtimeSignalEvaluations.length,
+          strategyRows,
+          runtimeGateWarningCounts
+        }),
+        { userName: flags.user }
+      );
+    }
+  } finally {
+    (0, import_backtest.resetTestingKlineCache)(projectRoot);
+  }
+};
+if (process.env.NODE_ENV !== "test") {
+  runtimeParity().then(() => {
+    process.exit(0);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRuntimeParityMessage,
+  runtimeParity
+});