@tradejs/cli 1.0.9 → 1.0.10

package/dist/scripts/replayRuntimeEvidence.js

@@ -0,0 +1,868 @@
+"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/replayRuntimeEvidence.ts
+var replayRuntimeEvidence_exports = {};
+__export(replayRuntimeEvidence_exports, {
+  main: () => main,
+  replayRuntimeEvidence: () => replayRuntimeEvidence
+});
+module.exports = __toCommonJS(replayRuntimeEvidence_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_args = __toESM(require("args"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_redis4 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeDebugEvidence.ts
+var import_redis3 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeRedis.ts
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var resolveStrategyConfigIdentityByKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+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 resolveStrategyNameByConfigKey = (userName, key) => {
+  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
+};
+var getRuntimeStrategyConfigKeys = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeStrategyConfigs = async (userName, {
+  onInvalidConfig
+} = {}) => {
+  const configKeys = await getRuntimeStrategyConfigKeys(userName);
+  const strategyConfigs = await Promise.all(
+    configKeys.map(async (key) => {
+      const strategyName = resolveStrategyNameByConfigKey(userName, key);
+      const identity = resolveStrategyConfigIdentityByKey(userName, key);
+      if (!strategyName || !identity) {
+        return null;
+      }
+      const strategyConfig = await (0, import_redis.getData)(
+        key,
+        null
+      );
+      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+        onInvalidConfig?.(key);
+        return null;
+      }
+      return {
+        key,
+        strategyName,
+        configId: identity.configId,
+        strategyConfig
+      };
+    })
+  );
+  return strategyConfigs.filter(Boolean);
+};
+var loadRuntimeTrades = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
+  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
+  if (hasWindow) {
+    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+    const bucketTrades = (await Promise.all(
+      dayKeys.map(
+        (dayKey) => (0, import_redis.getHashJsonValues)(
+          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
+        )
+      )
+    )).flat();
+    const dedupedBucketTrades = /* @__PURE__ */ new Map();
+    for (const trade of bucketTrades) {
+      if (!isRuntimeTradeRecord(trade)) {
+        continue;
+      }
+      dedupedBucketTrades.set(trade.orderId, trade);
+    }
+    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+    if (windowedTrades.length > 0 || dayKeys.length === 0) {
+      return windowedTrades;
+    }
+  }
+  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
+  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
+    (key) => !key.startsWith(bucketPrefix)
+  );
+  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var import_redis2 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var import_constants = require("@tradejs/core/constants");
+var import_time2 = require("@tradejs/core/time");
+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";
+};
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+
+// 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 filterBucketKeysByWindow = (bucketKeys, prefix, startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime == null || endTime == null) {
+    return bucketKeys;
+  }
+  const allowedDayKeys = new Set((0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime));
+  if (!allowedDayKeys.size) {
+    return [];
+  }
+  return bucketKeys.filter((key) => {
+    const suffix = key.slice(prefix.length);
+    const firstColon = suffix.indexOf(":");
+    if (firstColon <= 0) {
+      return false;
+    }
+    return allowedDayKeys.has(suffix.slice(0, firstColon));
+  });
+};
+var loadRuntimeSignals = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis2.redisKeys.runtimeSignalBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis2.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis2.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_redis2.getData)(
+        import_redis2.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var loadRuntimeSignalEvaluations = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis2.redisKeys.runtimeSignalEvaluationBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis2.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis2.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    deduped.set(evaluation.evaluationId, evaluation);
+  }
+  return sortByTimestamp([...deduped.values()]);
+};
+var parseBucketKey = (prefix, key) => {
+  if (!key.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = key.slice(prefix.length);
+  const firstColon = suffix.indexOf(":");
+  if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+    return null;
+  }
+  return {
+    dayKey: suffix.slice(0, firstColon),
+    strategy: suffix.slice(firstColon + 1)
+  };
+};
+var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
+  const prefix = import_redis2.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis2.getKeys)(prefix);
+  const entries = await Promise.all(
+    keys.map(async (key) => {
+      const parsedKey = parseBucketKey(prefix, key);
+      if (!parsedKey) {
+        return null;
+      }
+      return {
+        key,
+        ...parsedKey,
+        stats: parseRuntimeSignalStatsBucket(await (0, import_redis2.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+
+// src/lib/runtimeDebugEvidence.ts
+var RUNTIME_DEBUG_TIMEZONE = "Europe/Moscow";
+var formatRuntimeDebugDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+  timeZone: RUNTIME_DEBUG_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false
+}).format(new Date(timestamp));
+var buildRuntimeDebugEvaluationId = ({
+  strategy,
+  symbol,
+  timestamp
+}) => `${strategy}:${symbol}:${timestamp}`;
+var filterByStrategies = (values, strategies) => {
+  if (!strategies?.length) {
+    return values;
+  }
+  const strategySet = new Set(strategies);
+  return values.filter((value) => strategySet.has(value.strategy));
+};
+var collectRuntimeDebugEvidence = async ({
+  userName,
+  startTime,
+  endTime,
+  strategies
+}) => {
+  const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
+  const dayKeySet = new Set(dayKeys);
+  const [trades, signals, evaluations, evaluationStatsBuckets, configs] = await Promise.all([
+    loadRuntimeTrades(userName, { startTime, endTime }),
+    loadRuntimeSignals(userName, { startTime, endTime }),
+    loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
+    loadRuntimeSignalEvaluationStatsBuckets(userName),
+    loadRuntimeStrategyConfigs(userName)
+  ]);
+  const filteredStats = evaluationStatsBuckets.filter(
+    (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
+  );
+  return {
+    dayKeys,
+    trades: filterByStrategies(trades, strategies),
+    signals: filterByStrategies(signals, strategies),
+    evaluations: filterByStrategies(evaluations, strategies),
+    evaluationStatsBuckets: filteredStats,
+    strategyConfigs: configs.filter(
+      (config) => !strategies?.length || strategies.includes(config.strategyName)
+    )
+  };
+};
+var buildRuntimeDebugReportPayload = async ({
+  userName,
+  startTime,
+  endTime,
+  signals,
+  evaluations,
+  trades,
+  strategyConfigs,
+  evaluationStatsBuckets
+}) => {
+  const signalById = new Map(
+    signals.map((signal) => [signal.signalId, signal])
+  );
+  const evaluationById = new Map(
+    evaluations.map((evaluation) => [evaluation.evaluationId, evaluation])
+  );
+  const evaluationBySignalShape = new Map(
+    evaluations.map((evaluation) => [
+      buildRuntimeDebugEvaluationId(evaluation),
+      evaluation
+    ])
+  );
+  const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
+  const debugTrades = await Promise.all(
+    trades.map(async (trade) => {
+      const signal = trade.signalId != null ? signalById.get(trade.signalId) : void 0;
+      const evaluationId = buildRuntimeDebugEvaluationId({
+        strategy: trade.strategy,
+        symbol: trade.symbol,
+        timestamp: signal?.timestamp ?? trade.entryTimestamp
+      });
+      const knownEvaluation = evaluationById.get(evaluationId) ?? evaluationBySignalShape.get(evaluationId);
+      const tradeDayKey = (0, import_time2.getRuntimeStorageDayKey)(trade.entryTimestamp);
+      const signalDayKey = signal != null ? (0, import_time2.getRuntimeStorageDayKey)(signal.timestamp) : tradeDayKey;
+      const evaluationDayKey = knownEvaluation != null ? (0, import_time2.getRuntimeStorageDayKey)(knownEvaluation.timestamp) : signalDayKey;
+      const tradeKey = import_redis3.redisKeys.runtimeTrade(userName, trade.orderId);
+      const tradeBucketKey = import_redis3.redisKeys.runtimeTradeBucket(
+        userName,
+        tradeDayKey
+      );
+      const activeTradeKey = import_redis3.redisKeys.runtimeActiveTrade(
+        userName,
+        trade.symbol
+      );
+      const signalKey = trade.signalId != null ? import_redis3.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
+      const evaluationBucketKey = import_redis3.redisKeys.runtimeSignalEvaluationBucket(
+        userName,
+        evaluationDayKey,
+        knownEvaluation?.strategy ?? trade.strategy
+      );
+      const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
+      const evaluationKey = import_redis3.redisKeys.runtimeSignalEvaluation(
+        userName,
+        evaluationField
+      );
+      const [
+        tradeValue,
+        activeTradeValue,
+        signalValue,
+        directEvaluationValue,
+        bucketEvaluationValue
+      ] = await Promise.all([
+        (0, import_redis3.getData)(tradeKey, null),
+        (0, import_redis3.getData)(activeTradeKey, null),
+        signalKey ? (0, import_redis3.getData)(signalKey, null) : Promise.resolve(null),
+        (0, import_redis3.getData)(evaluationKey, null),
+        knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis3.getHashJsonField)(
+          evaluationBucketKey,
+          evaluationField,
+          null
+        )
+      ]);
+      const evaluationValue = directEvaluationValue ?? bucketEvaluationValue ?? knownEvaluation ?? null;
+      return {
+        redisDebug: {
+          trade: tradeKey,
+          tradeBucket: {
+            key: tradeBucketKey,
+            field: trade.orderId
+          },
+          activeTrade: activeTradeKey,
+          signal: signalKey,
+          evaluation: {
+            key: evaluationBucketKey,
+            field: evaluationField,
+            directKey: evaluationKey
+          }
+        },
+        trade,
+        redisValues: {
+          trade: tradeValue,
+          tradeBucket: trade,
+          activeTrade: activeTradeValue,
+          signal: signalValue ?? signal ?? null,
+          evaluation: evaluationValue ?? knownEvaluation ?? null
+        }
+      };
+    })
+  );
+  const linkedEvaluations = /* @__PURE__ */ new Map();
+  for (const trade of debugTrades) {
+    const evaluation = trade.redisValues.evaluation;
+    if (evaluation && typeof evaluation === "object" && "evaluationId" in evaluation && typeof evaluation.evaluationId === "string") {
+      linkedEvaluations.set(
+        evaluation.evaluationId,
+        evaluation
+      );
+    }
+  }
+  const reportEvaluations = evaluations.length > 0 ? evaluations : [...linkedEvaluations.values()];
+  return {
+    reportType: "runtime-daily-debug",
+    generatedAt: Date.now(),
+    generatedAtMsk: formatRuntimeDebugDateTime(Date.now()),
+    userName,
+    window: {
+      startTime,
+      endTime,
+      startMsk: formatRuntimeDebugDateTime(startTime),
+      endMsk: formatRuntimeDebugDateTime(endTime),
+      dayKeys
+    },
+    redisPrefixes: {
+      runtimeTrades: import_redis3.redisKeys.runtimeTrades(userName),
+      runtimeTradeBuckets: import_redis3.redisKeys.runtimeTradeBuckets(userName),
+      runtimeActiveTrades: import_redis3.redisKeys.runtimeActiveTrades(userName),
+      runtimeSignals: import_redis3.redisKeys.runtimeSignalBuckets(userName),
+      runtimeSignalEvaluations: import_redis3.redisKeys.runtimeSignalEvaluationBuckets(userName),
+      runtimeSignalEvaluationStats: import_redis3.redisKeys.runtimeSignalEvaluationStatsBuckets(userName)
+    },
+    counts: {
+      trades: trades.length,
+      signals: signals.length,
+      evaluations: reportEvaluations.length,
+      evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+      strategyConfigs: strategyConfigs?.length ?? 0
+    },
+    trades: debugTrades,
+    signals: signals.map((signal) => ({
+      redisKey: import_redis3.redisKeys.storeSignal(signal.symbol, signal.signalId),
+      signal
+    })),
+    evaluations: reportEvaluations.map((evaluation) => ({
+      redisDebug: {
+        key: import_redis3.redisKeys.runtimeSignalEvaluationBucket(
+          userName,
+          (0, import_time2.getRuntimeStorageDayKey)(evaluation.timestamp),
+          evaluation.strategy
+        ),
+        field: evaluation.evaluationId,
+        directKey: import_redis3.redisKeys.runtimeSignalEvaluation(
+          userName,
+          evaluation.evaluationId
+        )
+      },
+      evaluation
+    })),
+    evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+    strategyConfigs: strategyConfigs ?? []
+  };
+};
+
+// src/lib/replay/support.ts
+var import_chalk = __toESM(require("chalk"));
+var REPLAY_RESULTS_BY_STRATEGY_HEADERS = [
+  import_chalk.default.blue("STRATEGY"),
+  import_chalk.default.yellow("TICKERS"),
+  import_chalk.default.yellow("TRADE TICKERS"),
+  import_chalk.default.cyan("ORDERS"),
+  import_chalk.default.cyan("WIN/LOSS (%)"),
+  import_chalk.default.cyan("PROFIT"),
+  import_chalk.default.cyan("AVG TRADE")
+];
+var REPLAY_RUNTIME_COMPARISON_HEADERS = [
+  import_chalk.default.blue("STRATEGY"),
+  import_chalk.default.cyan("BT ENTRIES"),
+  import_chalk.default.cyan("BT PNL"),
+  import_chalk.default.yellow("RT TRADES"),
+  import_chalk.default.yellow("RT PNL"),
+  import_chalk.default.green("MATCHED"),
+  import_chalk.default.yellow("RT ONLY"),
+  import_chalk.default.magenta("BT ONLY")
+];
+var REPLAY_RESULTS_CONFIG = "replay";
+var REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS = 1;
+var REPLAY_RUNTIME_COMPARE_TOLERANCE_MS = REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS * 15 * 60 * 1e3;
+
+// src/scripts/replayRuntimeEvidence.ts
+import_args.default.option(["u", "user"], "Use user config", "root");
+import_args.default.option(
+  ["S", "startTime"],
+  "Window start timestamp, seconds/ms, or ISO date"
+);
+import_args.default.option(["E", "endTime"], "Window end timestamp, seconds/ms, or ISO date");
+import_args.default.option(
+  ["H", "hours"],
+  "Fallback window in hours when start/end are omitted",
+  24
+);
+import_args.default.option(["s", "strategy"], "Strategy filter, comma-separated");
+import_args.default.option("replayKey", "Exact replay result Redis key");
+import_args.default.option(
+  "runtimeEvidence",
+  "Runtime evidence JSON collected on the runtime server"
+);
+import_args.default.option(
+  ["o", "out"],
+  "Output JSON path",
+  "output/replay-runtime-evidence.json"
+);
+var flags = import_args.default.parse(process.argv);
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var toEpochMs = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const raw = String(value).trim();
+  if (/^\d+$/.test(raw)) {
+    const parsed2 = Number(raw);
+    return parsed2 < 1e12 ? Math.trunc(parsed2 * 1e3) : Math.trunc(parsed2);
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var resolveWindow = () => {
+  const endTime = toEpochMs(flags.endTime) ?? Date.now();
+  const hours = Math.max(
+    1,
+    Number.parseInt(String(flags.hours ?? 24), 10) || 24
+  );
+  const startTime = toEpochMs(flags.startTime) ?? endTime - hours * 60 * 60 * 1e3;
+  if (startTime >= endTime) {
+    throw new Error(
+      `Invalid window: startTime (${startTime}) must be less than endTime (${endTime})`
+    );
+  }
+  return {
+    startTime,
+    endTime,
+    source: flags.startTime != null || flags.endTime != null ? "explicit" : "hours"
+  };
+};
+var parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var asArray = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
+var sum = (items, getter) => Number(
+  items.reduce((total, item) => {
+    const value = getter(item);
+    return total + (typeof value === "number" && Number.isFinite(value) ? value : 0);
+  }, 0).toFixed(12)
+);
+var groupCount = (items, getter) => {
+  const counts = {};
+  for (const item of items) {
+    const raw = getter(item);
+    const key = typeof raw === "string" && raw.trim() ? raw : "[unknown]";
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return counts;
+};
+var compactMatched = (item) => {
+  const runtime = asRecord(item.runtime);
+  const backtest = asRecord(item.backtest);
+  const pnl = asRecord(item.pnl);
+  const slippage = asRecord(item.slippage);
+  return {
+    strategy: backtest.strategy ?? runtime.inferredStrategy ?? null,
+    runtimeInferredStrategy: runtime.inferredStrategy ?? null,
+    symbol: backtest.symbol ?? runtime.symbol ?? null,
+    direction: backtest.direction ?? runtime.direction ?? null,
+    timestamp: backtest.timestamp ?? null,
+    comparisonTimestamp: backtest.comparisonTimestamp ?? null,
+    runtimeTimestamp: runtime.timestamp ?? null,
+    timestampDiffMs: item.timestampDiffMs ?? null,
+    backtestPrice: backtest.price ?? null,
+    runtimePrice: runtime.price ?? null,
+    backtestExitPrice: backtest.exitPrice ?? null,
+    runtimeExitPrice: runtime.exitPrice ?? null,
+    expectedPnl: pnl.expectedPnl ?? null,
+    realizedPnl: pnl.realizedPnl ?? null,
+    pnlDelta: pnl.delta ?? null,
+    entrySlippageCost: slippage.entryCost ?? null,
+    exitSlippageCost: slippage.exitCost ?? null,
+    totalSlippageCost: slippage.totalCost ?? null,
+    orderId: runtime.orderId ?? backtest.orderId ?? null,
+    orderLinkId: runtime.orderLinkId ?? null,
+    signalId: backtest.signalId ?? null
+  };
+};
+var resolveItemStrategy = (item) => asRecord(item.backtest).strategy ?? asRecord(item.runtime).inferredStrategy ?? item.strategy ?? item.inferredStrategy ?? null;
+var summarizeReplayComparison = (runtimeComparison, strategies) => {
+  const comparison = asRecord(runtimeComparison);
+  const details = asRecord(comparison.details);
+  const strategySet = new Set(strategies);
+  const useFilter = strategySet.size > 0;
+  const hasStrategy = (item) => {
+    const strategy = resolveItemStrategy(item);
+    return !useFilter || typeof strategy === "string" && strategySet.has(strategy);
+  };
+  const matched = asArray(details.matched).filter(hasStrategy);
+  const backtestOnly = asArray(details.backtestOnly).filter(hasStrategy);
+  const runtimeOnly = asArray(details.runtimeOnly).filter(hasStrategy);
+  const drilldown = asRecord(details.mismatchDrilldown);
+  const drilldownBacktestOnly = asArray(drilldown.backtestOnly).filter(
+    (item) => hasStrategy(asRecord(item.entry))
+  );
+  const drilldownRuntimeOnly = asArray(drilldown.runtimeOnly).filter(
+    (item) => hasStrategy(asRecord(item.entry))
+  );
+  const strategyNames = useFilter ? strategies : [
+    ...new Set(
+      [...matched, ...backtestOnly, ...runtimeOnly].map(resolveItemStrategy).filter((value) => typeof value === "string")
+    )
+  ].sort((left, right) => left.localeCompare(right));
+  return {
+    mode: comparison.mode ?? null,
+    rows: asArray(comparison.rows).filter(
+      (row) => !useFilter || strategySet.has(String(row.strategyName ?? ""))
+    ),
+    counts: {
+      matched: matched.length,
+      backtestOnly: backtestOnly.length,
+      runtimeOnly: runtimeOnly.length
+    },
+    pnl: {
+      matchedExpected: sum(matched, (item) => asRecord(item.pnl).expectedPnl),
+      matchedRealized: sum(matched, (item) => asRecord(item.pnl).realizedPnl),
+      matchedDelta: sum(matched, (item) => asRecord(item.pnl).delta),
+      backtestOnlyExpected: sum(backtestOnly, (item) => item.pnl),
+      runtimeOnlyRealized: sum(runtimeOnly, (item) => item.pnl)
+    },
+    byStrategy: Object.fromEntries(
+      strategyNames.map((strategy) => {
+        const strategyMatched = matched.filter(
+          (item) => resolveItemStrategy(item) === strategy
+        );
+        const strategyBacktestOnly = backtestOnly.filter(
+          (item) => resolveItemStrategy(item) === strategy
+        );
+        const strategyRuntimeOnly = runtimeOnly.filter(
+          (item) => resolveItemStrategy(item) === strategy
+        );
+        return [
+          strategy,
+          {
+            matched: strategyMatched.length,
+            backtestOnly: strategyBacktestOnly.length,
+            runtimeOnly: strategyRuntimeOnly.length,
+            matchedRuntimeInferredStrategy: groupCount(
+              strategyMatched,
+              (item) => asRecord(item.runtime).inferredStrategy
+            ),
+            matchedExpectedPnl: sum(
+              strategyMatched,
+              (item) => asRecord(item.pnl).expectedPnl
+            ),
+            matchedRealizedPnl: sum(
+              strategyMatched,
+              (item) => asRecord(item.pnl).realizedPnl
+            ),
+            backtestOnlyExpectedPnl: sum(
+              strategyBacktestOnly,
+              (item) => item.pnl
+            ),
+            runtimeOnlyRealizedPnl: sum(
+              strategyRuntimeOnly,
+              (item) => item.pnl
+            )
+          }
+        ];
+      })
+    ),
+    matched: matched.map(compactMatched),
+    backtestOnly,
+    runtimeOnly,
+    mismatchDrilldown: {
+      summary: drilldown.summary ?? null,
+      backtestOnly: drilldownBacktestOnly,
+      runtimeOnly: drilldownRuntimeOnly
+    }
+  };
+};
+var loadReplayResult = async ({
+  userName,
+  replayKey
+}) => {
+  if (replayKey) {
+    return {
+      key: replayKey,
+      availableKeys: void 0,
+      value: await (0, import_redis4.getData)(replayKey, null)
+    };
+  }
+  const prefix = import_redis4.redisKeys.backtestResults(userName, REPLAY_RESULTS_CONFIG, "");
+  const keys = (await (0, import_redis4.getKeys)(prefix)).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const key = keys[keys.length - 1] ?? null;
+  return {
+    key,
+    availableKeys: keys.slice(-10),
+    value: key ? await (0, import_redis4.getData)(key, null) : null
+  };
+};
+var getReplayStrategies = (replayValue) => {
+  const replay = asRecord(replayValue);
+  const rows = [
+    ...asArray(replay.resultsByStrategies).map((row) => row.strategyName),
+    ...asArray(asRecord(replay.runtimeComparison).rows).map(
+      (row) => row.strategyName
+    )
+  ];
+  return [
+    ...new Set(
+      rows.filter((value) => typeof value === "string")
+    )
+  ].sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimePayload = async ({
+  startTime,
+  endTime,
+  strategies
+}) => {
+  const runtimeEvidencePath = typeof flags.runtimeEvidence === "string" && flags.runtimeEvidence.trim() ? import_node_path.default.resolve(projectRoot, flags.runtimeEvidence.trim()) : null;
+  if (runtimeEvidencePath) {
+    const artifact = JSON.parse(
+      await import_promises.default.readFile(runtimeEvidencePath, "utf8")
+    );
+    return {
+      source: "file",
+      path: runtimeEvidencePath,
+      payload: artifact.runtime ?? artifact
+    };
+  }
+  const runtimeEvidence = await collectRuntimeDebugEvidence({
+    userName: flags.user,
+    startTime,
+    endTime,
+    strategies: strategies.length ? strategies : void 0
+  });
+  return {
+    source: "local-redis",
+    path: null,
+    payload: await buildRuntimeDebugReportPayload({
+      userName: flags.user,
+      startTime,
+      endTime,
+      signals: runtimeEvidence.signals,
+      evaluations: runtimeEvidence.evaluations,
+      trades: runtimeEvidence.trades,
+      strategyConfigs: runtimeEvidence.strategyConfigs,
+      evaluationStatsBuckets: runtimeEvidence.evaluationStatsBuckets
+    })
+  };
+};
+var replayRuntimeEvidence = async () => {
+  const { startTime, endTime, source } = resolveWindow();
+  const replay = await loadReplayResult({
+    userName: flags.user,
+    replayKey: typeof flags.replayKey === "string" && flags.replayKey.trim() ? flags.replayKey.trim() : void 0
+  });
+  const explicitStrategies = parseStrategyFilter(flags.strategy);
+  const strategies = explicitStrategies.length ? explicitStrategies : getReplayStrategies(replay.value);
+  const runtime = await loadRuntimePayload({
+    startTime,
+    endTime,
+    strategies
+  });
+  const replayValue = asRecord(replay.value);
+  const artifact = {
+    reportType: "replay-runtime-evidence",
+    generatedAt: Date.now(),
+    userName: flags.user,
+    window: {
+      startTime,
+      endTime,
+      startIso: new Date(startTime).toISOString(),
+      endIso: new Date(endTime).toISOString(),
+      source
+    },
+    strategies,
+    runtimeSource: {
+      type: runtime.source,
+      path: runtime.path
+    },
+    replay: {
+      key: replay.key,
+      availableKeys: replay.availableKeys,
+      startedAt: replayValue.startedAt ?? null,
+      finishedAt: replayValue.finishedAt ?? null,
+      resultsByStrategies: asArray(replayValue.resultsByStrategies).filter(
+        (row) => !strategies.length || strategies.includes(String(row.strategyName ?? ""))
+      ),
+      runtimeComparison: summarizeReplayComparison(
+        replayValue.runtimeComparison,
+        strategies
+      )
+    },
+    runtime: runtime.payload
+  };
+  const outPath = import_node_path.default.resolve(projectRoot, String(flags.out));
+  await import_promises.default.mkdir(import_node_path.default.dirname(outPath), { recursive: true });
+  await import_promises.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+  console.log(import_chalk2.default.green(`Wrote ${outPath}`));
+  console.log(
+    JSON.stringify(
+      {
+        replayKey: artifact.replay.key,
+        strategies: artifact.strategies,
+        replayRows: artifact.replay.runtimeComparison.rows,
+        replayPnl: artifact.replay.runtimeComparison.pnl,
+        runtimeSource: artifact.runtimeSource,
+        runtimeCounts: asRecord(artifact.runtime).counts ?? null
+      },
+      null,
+      2
+    )
+  );
+};
+var main = replayRuntimeEvidence;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  replayRuntimeEvidence
+});