@tradejs/cli 3.1.29-beta.286 → 3.1.29-beta.288

package/dist/scripts/replayRunner.js

@@ -39,9 +39,482 @@ __export(replayRunner_exports, {
   resolveReplayStrategyNameFromExchangeEntry: () => resolveReplayStrategyNameFromExchangeEntry
 });
 module.exports = __toCommonJS(replayRunner_exports);
+
+// src/lib/replay/historicalSignalsReplayPreparation.ts
+var import_data = require("@tradejs/core/data");
+
+// src/lib/replay/support.ts
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/runtimeModeConfig.ts
+var buildRuntimeModeStrategyConfig = ({
+  strategyConfig,
+  env,
+  interval,
+  makeOrders,
+  recordRuntimeTrades,
+  aiReplayAnalyses
+}) => ({
+  ...strategyConfig,
+  ENV: env,
+  MAKE_ORDERS: makeOrders,
+  INTERVAL: strategyConfig.INTERVAL ?? interval,
+  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
+  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
+});
+
+// src/lib/replay/support.ts
+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.red("ORDER FAILED"),
+  import_chalk.default.yellow("RT ONLY"),
+  import_chalk.default.magenta("BT ONLY"),
+  import_chalk.default.red("UNMATCHED")
+];
+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;
+var formatReplayRuntimeCompareTolerance = () => `${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS} ${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS === 1 ? "bar" : "bars"}`;
+var getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly + row.backtestOnly;
+var buildReplayStrategyConfig = ({
+  strategyConfig,
+  interval
+}) => ({
+  ...buildRuntimeModeStrategyConfig({
+    strategyConfig,
+    env: "PARITY",
+    interval,
+    makeOrders: false,
+    recordRuntimeTrades: false
+  }),
+  SIMULATE_ORDERS: true
+});
+var toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var compactReplayAdditionalIndicators = (additionalIndicators) => {
+  const additional = toRecord(additionalIndicators);
+  if (!additional) {
+    return void 0;
+  }
+  const compact = {};
+  if (additional.executionSlippage != null) {
+    compact.executionSlippage = additional.executionSlippage;
+  }
+  if (additional.marketContext != null) {
+    compact.marketContext = additional.marketContext;
+  }
+  const baseContext = toRecord(additional.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const execution = toRecord(relative?.execution);
+  if (execution) {
+    compact.baseContext = {
+      relative: {
+        execution
+      }
+    };
+  }
+  return Object.keys(compact).length ? compact : void 0;
+};
+var compactReplaySignal = (signal) => {
+  if (!signal) {
+    return void 0;
+  }
+  return {
+    signalId: signal.signalId,
+    strategy: signal.strategy,
+    symbol: signal.symbol,
+    interval: signal.interval,
+    direction: signal.direction,
+    timestamp: signal.timestamp,
+    prices: signal.prices,
+    indicators: {},
+    figures: {},
+    additionalIndicators: compactReplayAdditionalIndicators(
+      signal.additionalIndicators
+    ),
+    isConfigFromBacktest: signal.isConfigFromBacktest,
+    ...signal.orderStatus ? { orderStatus: signal.orderStatus } : {},
+    ...signal.orderSkipReason ? { orderSkipReason: signal.orderSkipReason } : {},
+    ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
+    ...signal.ml ? { ml: signal.ml } : {}
+  };
+};
+
+// src/lib/marketData/windows.ts
+var import_indicators = require("@tradejs/core/indicators");
+var splitCandlesForReplayWindow = (candles, start, preloadStart) => {
+  const prevData = [];
+  const replayData = [];
+  for (const candle of candles) {
+    if (candle.timestamp < preloadStart) {
+      continue;
+    }
+    if (candle.timestamp < start) {
+      prevData.push(candle);
+      continue;
+    }
+    replayData.push(candle);
+  }
+  return { prevData, replayData };
+};
+var alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
+
+// src/lib/replay/historicalSignalsReplayPreparation.ts
+var buildPreparedData = ({
+  data,
+  btcData,
+  ethData,
+  btcBinanceData,
+  btcCoinbaseData,
+  start,
+  preloadStart
+}) => {
+  const { prevData: prevDataRaw, replayData: replayDataRaw } = splitCandlesForReplayWindow(data, start, preloadStart);
+  const { prevData: btcPrevDataRaw, replayData: btcReplayDataRaw } = splitCandlesForReplayWindow(btcData, start, preloadStart);
+  const { prevData: ethPrevDataRaw, replayData: ethReplayDataRaw } = splitCandlesForReplayWindow(ethData, start, preloadStart);
+  const { prevData: btcBinancePrevDataRaw } = splitCandlesForReplayWindow(
+    btcBinanceData,
+    start,
+    preloadStart
+  );
+  const { prevData: btcCoinbasePrevDataRaw } = splitCandlesForReplayWindow(
+    btcCoinbaseData,
+    start,
+    preloadStart
+  );
+  const { alignedCoinCandles: prevData, alignedBtcCandles: btcPrevData } = alignSymbolWithBtcReference(prevDataRaw, btcPrevDataRaw);
+  const { alignedCoinCandles: replayData, alignedBtcCandles: btcReplayData } = alignSymbolWithBtcReference(replayDataRaw, btcReplayDataRaw);
+  const { alignedBtcCandles: ethPrevData } = alignSymbolWithBtcReference(
+    prevData,
+    ethPrevDataRaw
+  );
+  const { alignedBtcCandles: ethReplayData } = alignSymbolWithBtcReference(
+    replayData,
+    ethReplayDataRaw
+  );
+  const { alignedBtcCandles: btcBinancePrevData } = alignSymbolWithBtcReference(
+    prevDataRaw,
+    btcBinancePrevDataRaw
+  );
+  const { alignedBtcCandles: btcCoinbasePrevData } = alignSymbolWithBtcReference(prevDataRaw, btcCoinbasePrevDataRaw);
+  return {
+    prevData,
+    btcPrevData,
+    ethPrevData,
+    replayData,
+    btcReplayData,
+    ethReplayData,
+    btcBinancePrevData,
+    btcCoinbasePrevData
+  };
+};
+var strategyIncludesSymbol = (strategy, symbol) => {
+  const tickers = strategy.selection?.tickers;
+  if (!tickers) return true;
+  const normalizedSymbol = symbol.trim().toUpperCase();
+  return tickers.some(
+    (ticker) => ticker.trim().toUpperCase() === normalizedSymbol
+  );
+};
+var buildSymbolSharedReplayKey = ({
+  userName,
+  connectorName,
+  interval,
+  symbol,
+  start,
+  end
+}) => ["replay", userName, connectorName, symbol, interval, start, end].join(":");
+var resolveHistoricalReplayIntervals = (baseInterval, strategyIntervals) => {
+  const intervals = [
+    ...new Set(
+      strategyIntervals.map((value) => {
+        if (!value || !Number.isFinite((0, import_data.intervalToMs)(value)) || (0, import_data.intervalToMs)(value) <= 0)
+          throw new Error(`Invalid replay strategy interval: ${value}`);
+        return value;
+      })
+    )
+  ].sort((a, b) => (0, import_data.intervalToMs)(a) - (0, import_data.intervalToMs)(b));
+  if (intervals.length > 1 && intervals.includes("M")) {
+    throw new Error("Mixed replay does not support calendar intervals");
+  }
+  const baseMs = (0, import_data.intervalToMs)(baseInterval);
+  if (intervals.some(
+    (value) => (0, import_data.intervalToMs)(value) < baseMs || (0, import_data.intervalToMs)(value) % baseMs !== 0
+  )) {
+    throw new Error(
+      "Replay strategy intervals must be multiples of the base timeframe"
+    );
+  }
+  if (!intervals.length || !intervals.includes(baseInterval)) {
+    throw new Error(
+      "Replay base timeframe must match an active strategy interval"
+    );
+  }
+  return intervals;
+};
+var prepareMultiIntervalHistoricalReplay = async (context, adapters, loadReferences) => {
+  const intervals = resolveHistoricalReplayIntervals(
+    context.interval,
+    context.strategies.map((s) => s.strategyConfig.INTERVAL)
+  );
+  const baseMs = (0, import_data.intervalToMs)(context.interval);
+  const plan = {
+    symbolRuntimes: [],
+    orderedTimestamps: [],
+    sharedReplayKeyPrefixes: [],
+    runtimeLineages: []
+  };
+  const timestamps = /* @__PURE__ */ new Set();
+  const baseRuntimes = /* @__PURE__ */ new Map();
+  const validatedSymbols = /* @__PURE__ */ new Set();
+  try {
+    for (const interval of intervals) {
+      const offset = (0, import_data.intervalToMs)(interval) - baseMs;
+      const nativeRun = {
+        ...context.preparedRun,
+        preloadStart: context.preparedRun.preloadStart - offset,
+        window: {
+          ...context.preparedRun.window,
+          start: context.preparedRun.window.start - offset,
+          end: context.preparedRun.window.end - offset
+        }
+      };
+      const part = await prepareHistoricalReplay(
+        {
+          ...context,
+          interval,
+          preparedRun: nativeRun,
+          strategies: context.strategies.filter(
+            (strategy) => strategy.strategyConfig.INTERVAL === interval
+          ),
+          references: interval === context.interval ? context.references : await loadReferences(interval, nativeRun)
+        },
+        adapters
+      );
+      plan.sharedReplayKeyPrefixes.push(...part.sharedReplayKeyPrefixes);
+      plan.runtimeLineages.push(...part.runtimeLineages);
+      for (const runtime of part.symbolRuntimes) {
+        if (interval === context.interval) {
+          baseRuntimes.set(runtime.symbol, runtime);
+        } else if (runtime.strategies.length && !validatedSymbols.has(runtime.symbol)) {
+          assertBaseReplayCoverage(
+            baseRuntimes.get(runtime.symbol),
+            runtime.symbol,
+            context.preparedRun.window,
+            baseMs
+          );
+          validatedSymbols.add(runtime.symbol);
+        }
+        runtime.timestampOffsetMs = offset;
+        runtime.advanceMarket = interval === context.interval;
+        plan.symbolRuntimes.push(runtime);
+      }
+      for (const timestamp of part.orderedTimestamps) {
+        const scheduled = timestamp + offset;
+        if (scheduled >= context.preparedRun.window.start && scheduled <= context.preparedRun.window.end)
+          timestamps.add(scheduled);
+      }
+    }
+    plan.orderedTimestamps = [...timestamps].sort((a, b) => a - b);
+    return plan;
+  } catch (error) {
+    releaseHistoricalReplayCaches(plan, adapters);
+    throw error;
+  }
+};
+var assertBaseReplayCoverage = (runtime, symbol, window, baseMs) => {
+  let index = 0;
+  for (let timestamp = Math.ceil(window.start / baseMs) * baseMs; timestamp <= window.end; timestamp += baseMs) {
+    if (runtime?.replayData[index]?.timestamp !== timestamp) {
+      throw new Error(`Missing base replay candle: ${symbol} at ${timestamp}`);
+    }
+    index += 1;
+  }
+};
+var prepareHistoricalReplay = async (context, adapters) => {
+  const {
+    userName,
+    projectRoot,
+    preparedRun,
+    interval,
+    connectorName,
+    replayConnector,
+    strategies,
+    references
+  } = context;
+  const symbolRuntimes = [];
+  const orderedTimestamps = /* @__PURE__ */ new Set();
+  const sharedReplayKeyPrefixes = [];
+  const runtimeLineages = [];
+  let skippedSymbols = 0;
+  try {
+    for (const symbol of preparedRun.tickers) {
+      const data = await preparedRun.marketConnector.kline({
+        symbol,
+        start: preparedRun.preloadStart,
+        end: preparedRun.window.end,
+        cacheOnly: true,
+        interval
+      });
+      if (symbolRuntimes.length % 50 === 0)
+        adapters.sampleMemory?.("history:loaded", {
+          symbols: symbolRuntimes.length + 1,
+          candles: data.length
+        });
+      const preparedData = buildPreparedData({
+        data,
+        btcData: references.btcMarketData,
+        ethData: references.ethMarketData,
+        btcBinanceData: references.btcBinanceData,
+        btcCoinbaseData: references.btcCoinbaseData,
+        start: preparedRun.window.start,
+        preloadStart: preparedRun.preloadStart
+      });
+      if (!preparedData.replayData.length || !preparedData.btcReplayData.length) {
+        skippedSymbols += 1;
+        adapters.progress.tick({
+          skipped: adapters.display.skipped(skippedSymbols),
+          symbol: adapters.display.symbol(symbol)
+        });
+        continue;
+      }
+      const sharedIndicatorsReplayKey = buildSymbolSharedReplayKey({
+        userName,
+        connectorName,
+        interval,
+        symbol,
+        start: preparedRun.window.start,
+        end: preparedRun.window.end
+      });
+      sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
+      const initializedStrategies = await Promise.allSettled(
+        strategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(async (strategy) => {
+          const replayStrategyConfig = buildReplayStrategyConfig({
+            strategyConfig: strategy.strategyConfig,
+            interval
+          });
+          const runtimeLineage = await adapters.buildLineage({
+            projectRoot,
+            strategyName: strategy.strategyName,
+            strategyRevision: strategy.strategyRevision,
+            deploymentCompositionId: strategy.deploymentCompositionId,
+            strategyPackageVersion: strategy.strategyPackageVersion,
+            strategyDependencyVersions: strategy.strategyDependencyVersions,
+            runtimePackageVersion: strategy.runtimePackageVersion,
+            config: {
+              configId: strategy.strategyRevision,
+              strategyConfig: strategy.strategyConfig,
+              symbolResultConfig: strategy.strategyResults?.[symbol]?.config ?? null
+            },
+            runContext: {
+              connectorName: connectorName.toLowerCase(),
+              interval: String(interval),
+              universe: preparedRun.universe ?? null
+            }
+          });
+          runtimeLineages.push({
+            strategy: strategy.strategyName,
+            symbol,
+            ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
+            ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
+            lineage: runtimeLineage
+          });
+          return {
+            strategyName: strategy.strategyName,
+            strategyConfig: strategy.strategyConfig,
+            runtimeLineage,
+            run: await strategy.strategyCreator({
+              userName,
+              connectorName,
+              runtimeConfigId: strategy.strategyRevision,
+              strategyRevision: strategy.strategyRevision,
+              runtimeLineage,
+              universe: preparedRun.universe,
+              accountId: preparedRun.accountId,
+              deploymentId: preparedRun.deploymentId,
+              runtimeConfigSnapshot: {
+                userConfig: replayStrategyConfig
+              },
+              config: replayStrategyConfig,
+              symbol,
+              data: preparedData.prevData,
+              btcData: preparedData.btcPrevData,
+              ethData: preparedData.ethPrevData,
+              btcBinanceData: preparedData.btcBinancePrevData,
+              btcCoinbaseData: preparedData.btcCoinbasePrevData,
+              connector: replayConnector,
+              sharedIndicatorsReplayKey
+            })
+          };
+        })
+      );
+      const strategiesForSymbol = initializedStrategies.map((result) => {
+        if (result.status === "rejected") throw result.reason;
+        return result.value;
+      });
+      const symbolRuntime = {
+        symbol,
+        replayData: preparedData.replayData,
+        btcReplayData: preparedData.btcReplayData,
+        ethReplayData: preparedData.ethReplayData,
+        currentIndex: 0,
+        strategies: strategiesForSymbol
+      };
+      symbolRuntimes.push(symbolRuntime);
+      if (symbolRuntimes.length % 50 === 0 || symbol === preparedRun.tickers.at(-1))
+        adapters.sampleMemory?.("strategies:initializing", {
+          symbols: symbolRuntimes.length,
+          strategiesPerSymbol: strategiesForSymbol.length
+        });
+      adapters.progress.tick({
+        skipped: adapters.display.skipped(skippedSymbols),
+        symbol: adapters.display.symbol(symbol)
+      });
+      for (const candle of preparedData.replayData) {
+        orderedTimestamps.add(candle.timestamp);
+      }
+    }
+    return {
+      symbolRuntimes,
+      orderedTimestamps: [...orderedTimestamps].sort(
+        (left, right) => left - right
+      ),
+      sharedReplayKeyPrefixes,
+      runtimeLineages
+    };
+  } catch (error) {
+    releaseHistoricalReplayCaches({ sharedReplayKeyPrefixes }, adapters);
+    throw error;
+  }
+};
+var releaseHistoricalReplayPlan = (plan) => {
+  plan.symbolRuntimes.length = 0;
+  plan.sharedReplayKeyPrefixes.length = 0;
+};
+var releaseHistoricalReplayCaches = (plan, adapters) => {
+  for (const keyPrefix of plan.sharedReplayKeyPrefixes) {
+    adapters.releaseIndicatorsCache(keyPrefix);
+    adapters.releaseReplayCache(keyPrefix);
+  }
+};
+
+// src/scripts/replayRunner.ts
 var import_chalk13 = __toESM(require("chalk"));
 var import_constants7 = require("@tradejs/core/constants");
-var import_data3 = require("@tradejs/core/data");
+var import_data5 = require("@tradejs/core/data");
 var import_time7 = require("@tradejs/core/time");
 var import_redis6 = require("@tradejs/infra/redis");
 var import_candles = require("@tradejs/infra/timescale/candles");
@@ -74,7 +547,7 @@ var timeOperation = async (label, operation, log = console.log) => {
 };
 
 // src/lib/runEnvironment.ts
-var import_chalk3 = __toESM(require("chalk"));
+var import_chalk4 = __toESM(require("chalk"));
 var import_connectors3 = require("@tradejs/node/connectors");
 var import_cli3 = require("@tradejs/node/cli");
 var import_constants = require("@tradejs/core/constants");
@@ -82,7 +555,7 @@ var import_time2 = require("@tradejs/core/time");
 var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
 
 // src/lib/runtimeStrategyBacktest.ts
-var import_chalk = __toESM(require("chalk"));
+var import_chalk2 = __toESM(require("chalk"));
 
 // src/lib/runtimeRedis.ts
 var import_redis = require("@tradejs/infra/redis");
@@ -232,7 +705,7 @@ var resolveTimeWindow = ({
 };
 
 // src/lib/marketData/historyPrepare.ts
-var import_chalk2 = __toESM(require("chalk"));
+var import_chalk3 = __toESM(require("chalk"));
 var import_connectors = require("@tradejs/connectors");
 var import_cli = require("@tradejs/node/cli");
 var import_connectors2 = require("@tradejs/node/connectors");
@@ -323,7 +796,7 @@ var updatePrimaryMarketHistory = async ({
   const timeOperation3 = (label, operation) => timeOperation(
     label,
     operation,
-    log ?? ((message) => console.log(import_chalk2.default.gray(message)))
+    log ?? ((message) => console.log(import_chalk3.default.gray(message)))
   );
   const updateOptions = preloadStart != null || preloadEnd != null ? {
     connectorLabel: connectorName,
@@ -355,7 +828,7 @@ var updateBtcReferenceHistory = async ({
   const timeOperation3 = (label, operation) => timeOperation(
     label,
     operation,
-    log ?? ((message) => console.log(import_chalk2.default.gray(message)))
+    log ?? ((message) => console.log(import_chalk3.default.gray(message)))
   );
   const updateReference = async ({
     connector,
@@ -477,7 +950,7 @@ var loadRunTickers = async ({
 var timeOperation2 = async (label, operation) => timeOperation(
   label,
   operation,
-  (message) => console.log(import_chalk3.default.gray(message))
+  (message) => console.log(import_chalk4.default.gray(message))
 );
 var resolveBacktestExecutionPreloadInterval = (interval) => {
   const normalized = String(interval);
@@ -498,7 +971,7 @@ var resolveRunConnectorName = async ({
     return connectorName;
   }
   console.log(
-    import_chalk3.default.yellow(
+    import_chalk4.default.yellow(
       `Unknown connector "${String(value || "").trim() || String(value)}". Fallback to ${import_connectors3.DEFAULT_CONNECTOR_NAME}.`
     )
   );
@@ -553,7 +1026,7 @@ var loadDeploymentReplayStrategies = async ({
   ) : [];
   if (!strategies.length) {
     console.log(
-      import_chalk3.default.yellow(
+      import_chalk4.default.yellow(
         `No enabled strategies found in runtime deployment ${deploymentId}`
       )
     );
@@ -619,7 +1092,7 @@ var prepareRunEnvironment = async ({
     );
   }
   if (showTickersList) {
-    console.log(import_chalk3.default.gray(JSON.stringify(loadedTickers.sort(), null, 2)));
+    console.log(import_chalk4.default.gray(JSON.stringify(loadedTickers.sort(), null, 2)));
     return null;
   }
   const instruments = !cacheOnly && typeof marketConnector.listInstruments === "function" ? await timeOperation2(
@@ -656,7 +1129,7 @@ var prepareRunEnvironment = async ({
       projectRoot,
       shouldUseDedicatedReferences: universe === "crypto",
       requireDedicatedReferences: universe === "crypto",
-      warn: (message) => console.log(import_chalk3.default.yellow(message))
+      warn: (message) => console.log(import_chalk4.default.yellow(message))
     });
     await updateMarketHistoryWithBtcReferences({
       marketConnector,
@@ -667,7 +1140,7 @@ var prepareRunEnvironment = async ({
       preloadStart,
       preloadEnd: window.end,
       universe,
-      log: (message) => console.log(import_chalk3.default.gray(message))
+      log: (message) => console.log(import_chalk4.default.gray(message))
     });
     const backtestExecutionInterval = resolveBacktestExecutionPreloadInterval(interval);
     if (import_constants.BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED && backtestExecutionInterval && String(backtestExecutionInterval) !== String(interval)) {
@@ -704,13 +1177,13 @@ var prepareRunEnvironment = async ({
 };
 
 // src/lib/marketContextPrepare.ts
-var import_chalk7 = __toESM(require("chalk"));
+var import_chalk8 = __toESM(require("chalk"));
 var import_marketContext3 = require("@tradejs/infra/timescale/marketContext");
 var import_registry = require("@tradejs/node/registry");
 
 // src/lib/binanceMarketContextBackfill.ts
 var import_progress = __toESM(require("progress"));
-var import_chalk4 = __toESM(require("chalk"));
+var import_chalk5 = __toESM(require("chalk"));
 var import_connectors4 = require("@tradejs/connectors");
 var import_connectors5 = require("@tradejs/node/connectors");
 var import_strategies = require("@tradejs/node/strategies");
@@ -1264,7 +1737,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
   let tradeFlowRows = 0;
   let breadthRows = 0;
   console.log(
-    import_chalk4.default.cyan(
+    import_chalk5.default.cyan(
       `binance market context backfill: requestedSymbols=${symbols.length}, referenceSymbols=${referenceSymbols.length}, interval=${interval}, tradeFlowWindow=${new Date(tradeFlowStartMs).toISOString()}..${new Date(endMs).toISOString()}, breadthWindow=${new Date(breadthStartMs).toISOString()}..${new Date(endMs).toISOString()}`
     )
   );
@@ -1400,7 +1873,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
         }) : [];
         if (!missingChunks2.length) {
           console.log(
-            import_chalk4.default.gray(`breadth cached: universe=${definition.universe}`)
+            import_chalk5.default.gray(`breadth cached: universe=${definition.universe}`)
           );
         }
         return {
@@ -1488,7 +1961,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     }
   }
   console.log(
-    import_chalk4.default.green(
+    import_chalk5.default.green(
       `binance market context backfill done: tradeFlowRows=${tradeFlowRows}, depthRows=0, breadthRows=${breadthRows}, skippedSymbols=${skippedSymbols}`
     )
   );
@@ -1505,11 +1978,11 @@ var backfillBinanceMarketContextForSignals = (params) => backfillBinanceMarketCo
 var backfillBinanceMarketContextForReplay = (params) => backfillBinanceMarketContext(params, true);
 
 // src/lib/derivativesContextBackfill.ts
-var import_chalk5 = __toESM(require("chalk"));
+var import_chalk6 = __toESM(require("chalk"));
 var import_progress2 = __toESM(require("progress"));
 var import_async = require("@tradejs/core/async");
 var import_constants2 = require("@tradejs/core/constants");
-var import_indicators = require("@tradejs/core/indicators");
+var import_indicators2 = require("@tradejs/core/indicators");
 var import_derivatives = require("@tradejs/infra/timescale/derivatives");
 var import_client2 = require("@tradejs/infra/timescale/client");
 var import_userSettings = require("@tradejs/infra/userSettings");
@@ -1612,7 +2085,7 @@ var resolveDerivativesContextBackfillWindow = (params) => {
 };
 var resolveDerivativesContextIntervalBackfillWindow = (params) => {
   const intervalMs = derivativesIntervalMs(params.interval);
-  const alignedToMs = params.closedOnly ? (0, import_indicators.getLastClosedDerivativesBarStartMs)(params.toMs, params.interval) : Math.floor(params.toMs / intervalMs) * intervalMs;
+  const alignedToMs = params.closedOnly ? (0, import_indicators2.getLastClosedDerivativesBarStartMs)(params.toMs, params.interval) : Math.floor(params.toMs / intervalMs) * intervalMs;
   return {
     fromMs: Math.floor(params.fromMs / intervalMs) * intervalMs,
     toMs: alignedToMs,
@@ -1649,7 +2122,7 @@ var resolveDerivativesContextRequiredFetchFromMs = (params) => {
     refreshClosedTail: params.mode === "signals"
   });
   const dataFetchFromMs = dataCoverageFromMs != null && edgesFromMs != null ? Math.max(dataCoverageFromMs, edgesFromMs) : null;
-  const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+  const confirmedLiquidationWindow = (0, import_indicators2.resolveCoinalyzeConfirmedIntradayCoverage)({
     interval: params.interval,
     fromMs: params.fromMs,
     toMs: params.toMs,
@@ -2040,7 +2513,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
   const coverageNowMs = Date.now();
   await Promise.all(
     intervalWindows.map(async (window) => {
-      const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+      const confirmedLiquidationWindow = (0, import_indicators2.resolveCoinalyzeConfirmedIntradayCoverage)({
         interval: window.interval,
         fromMs: window.fromMs,
         toMs: window.toMs,
@@ -2136,7 +2609,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
             toMs: backfillWindow.toMs
           })
         );
-        const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+        const confirmedLiquidationWindow = (0, import_indicators2.resolveCoinalyzeConfirmedIntradayCoverage)({
           interval: window.interval,
           fromMs: backfillWindow.fromMs,
           toMs: backfillWindow.toMs,
@@ -2154,7 +2627,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
   });
   if (allBackfillWindowsCached) {
     console.log(
-      import_chalk5.default.gray(
+      import_chalk6.default.gray(
         `derivatives context backfill: cached symbols=${symbols.length}, requestedSymbols=${requestedSymbols.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}`
       )
     );
@@ -2219,7 +2692,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
   let failedWindows = 0;
   let skippedWindows = 0;
   console.log(
-    import_chalk5.default.cyan(
+    import_chalk6.default.cyan(
       `derivatives context backfill: symbols=${matches.length}, requestedSymbols=${requestedSymbols.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}, testStart=${new Date(safeStartMs).toISOString()}`
     )
   );
@@ -2324,13 +2797,13 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
                 });
                 rows = missingBatch.flatMap((item) => {
                   const marketSymbol = item.marketSymbol.toUpperCase();
-                  const points = (0, import_indicators.mergeCoinalyzeMetrics)({
+                  const points = (0, import_indicators2.mergeCoinalyzeMetrics)({
                     symbol: item.symbol,
                     oiRaw: oiMap.get(marketSymbol) ?? [],
                     fundingRaw: fundingMap.get(marketSymbol) ?? [],
                     liqRaw: liquidationRowsByMarket.get(marketSymbol) ?? []
                   });
-                  return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
+                  return (0, import_indicators2.coinalyzePointsToRows)(points, interval, "coinalyze");
                 });
                 missingClosedSymbols = mode === "signals" ? getMissingClosedDerivativesSymbols({
                   symbols: missingBatch.map((item) => item.symbol),
@@ -2351,7 +2824,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
                 await (0, import_derivatives.upsertDerivatives)(rows);
                 totalRows += rows.length;
               }
-              const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+              const confirmedLiquidationWindow = (0, import_indicators2.resolveCoinalyzeConfirmedIntradayCoverage)({
                 interval,
                 fromMs: group.fromMs,
                 toMs,
@@ -2361,7 +2834,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
                 const metricCoverageRows = missingBatch.map((item) => {
                   const marketSymbol = item.marketSymbol.toUpperCase();
                   const eventRowsCount = (liquidationRowsByMarket.get(marketSymbol) ?? []).filter((point) => {
-                    const timestamp = (0, import_indicators.toCoinalyzeTimestampMs)(
+                    const timestamp = (0, import_indicators2.toCoinalyzeTimestampMs)(
                       point.t ?? point.ts ?? point.time ?? point.timestamp
                     );
                     return timestamp != null && timestamp >= confirmedLiquidationWindow.fromMs && timestamp <= confirmedLiquidationWindow.toMs;
@@ -2433,13 +2906,13 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
         } catch (error) {
           failedWindows += 1;
           console.error(
-            import_chalk5.default.red(
+            import_chalk6.default.red(
               `derivatives context backfill window failed batch=${batchIdx + 1}/${symbolBatches.length} interval=${interval} ${new Date(cursor).toISOString()}..${new Date(toMs).toISOString()}: ${error}`
             )
           );
         } finally {
           bar.tick(1, {
-            batch: import_chalk5.default.gray(
+            batch: import_chalk6.default.gray(
               `${batchIdx + 1}/${symbolBatches.length} ${interval}`
             ),
             rows: totalRows,
@@ -2453,7 +2926,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
   }
   console.log("");
   console.log(
-    import_chalk5.default.green(
+    import_chalk6.default.green(
       `derivatives context backfill done: rows=${totalRows}, failed_windows=${failedWindows}, skipped_windows=${skippedWindows}`
     )
   );
@@ -2483,7 +2956,7 @@ var backfillDerivativesContextForSignals = async (params) => backfillDerivatives
 );
 
 // src/lib/coinMarketCapContextBackfill.ts
-var import_chalk6 = __toESM(require("chalk"));
+var import_chalk7 = __toESM(require("chalk"));
 var import_async2 = require("@tradejs/core/async");
 var import_marketContext2 = require("@tradejs/infra/timescale/marketContext");
 var import_client3 = require("@tradejs/infra/timescale/client");
@@ -2745,7 +3218,7 @@ var formatRowTimeRange = (rows) => {
 };
 var logBackfillSourceDone = (params) => {
   console.log(
-    import_chalk6.default.gray(
+    import_chalk7.default.gray(
       `coinmarketcap context source done: ${params.name}=${params.status} rows=${params.rows}${params.details ? ` ${params.details}` : ""}`
     )
   );
@@ -2779,7 +3252,7 @@ var coinMarketCapFetch = async (params) => {
       recordCoinMarketCapFetchStats(params.stats, params.path, creditCount);
       if (creditCount != null && isVerboseRequestLoggingEnabled()) {
         console.log(
-          import_chalk6.default.gray(`coinmarketcap ${params.path}: credits=${creditCount}`)
+          import_chalk7.default.gray(`coinmarketcap ${params.path}: credits=${creditCount}`)
         );
       }
       return payload;
@@ -2824,7 +3297,7 @@ var fetchCoinMarketCapIndexRows = async (params) => {
     );
     if (chunk === 1 || chunk === totalChunks || chunk % 25 === 0) {
       console.log(
-        import_chalk6.default.gray(
+        import_chalk7.default.gray(
           `coinmarketcap index backfill progress: ${params.index.slug} chunk=${chunk}/${totalChunks} rows=${rows.length} chunkRange=${new Date(cursorMs).toISOString()}..${new Date(chunkEndMs).toISOString()}`
         )
       );
@@ -3263,7 +3736,7 @@ var backfillCoinMarketCapContext = async (params) => {
     covered: indexesBackfillCovered
   });
   console.log(
-    import_chalk6.default.gray(
+    import_chalk7.default.gray(
       [
         "coinmarketcap context status:",
         formatSourceStatus({
@@ -3298,7 +3771,7 @@ var backfillCoinMarketCapContext = async (params) => {
   );
   if (globalDailyReady && referencesDailyReady && exchangeLiquidityReady && fearGreedReady && indexesReady) {
     console.log(
-      import_chalk6.default.gray(
+      import_chalk7.default.gray(
         `coinmarketcap context cached: ${new Date(fromMs).toISOString()}..${new Date(toMs).toISOString()}`
       )
     );
@@ -3325,7 +3798,7 @@ var backfillCoinMarketCapContext = async (params) => {
     !indexesReady ? "indexes" : null
   ].filter((source) => source != null);
   console.log(
-    import_chalk6.default.cyan(
+    import_chalk7.default.cyan(
       `coinmarketcap context backfill: window=${new Date(fromMs).toISOString()}..${new Date(toMs).toISOString()} days=${Math.floor((toMs - fromMs) / DAY_MS3) + 1} fetch=${pendingSources.join(",")}`
     )
   );
@@ -3517,7 +3990,7 @@ var backfillCoinMarketCapContext = async (params) => {
     });
   }
   console.log(
-    import_chalk6.default.green(
+    import_chalk7.default.green(
       [
         "coinmarketcap context backfill done:",
         `global=${globalStatus} rows=${globalRows}`,
@@ -4129,7 +4602,7 @@ var buildDerivativesBackfillParams = (params) => ({
 });
 var prepareMarketContextForRun = async (params) => {
   const log = params.log ?? ((message) => {
-    console.log(import_chalk7.default.gray(message));
+    console.log(import_chalk8.default.gray(message));
   });
   const timeOperation3 = (label, operation) => timeOperation(label, operation, log);
   const requirements = await resolveMarketContextRunRequirements(params);
@@ -4580,174 +5053,64 @@ var buildRuntimeEvidenceLineageScopes = ({
     (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.firstTimestamp - right.firstTimestamp
   );
 };
-var loadReplayRuntimeEvidenceSource = async ({
-  filePath,
-  projectRoot,
-  expectedUserName,
-  expectedWindow
-}) => {
-  const { resolvedPath, runtime, userName, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot });
-  if (!userName || userName !== expectedUserName) {
-    throw new Error(
-      `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName || "missing"}`
-    );
-  }
-  const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
-  if (startTime !== expectedWindow.start || !endTimeMatches) {
-    throw new Error(
-      `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
-    );
-  }
-  const trades = unwrapRows(runtime.trades, "trade");
-  const signals = unwrapRows(runtime.signals, "signal");
-  const evaluations = unwrapRows(
-    runtime.evaluations,
-    "evaluation"
-  );
-  const storedLineageScopes = unwrapRows(
-    runtime.lineageScopes,
-    "lineageScope"
-  );
-  assertRuntimeRowsMatchDeployment({
-    label: "trade",
-    rows: trades,
-    deployment
-  });
-  assertRuntimeRowsMatchDeployment({
-    label: "signal",
-    rows: signals,
-    deployment
-  });
-  assertRuntimeRowsMatchDeployment({
-    label: "evaluation",
-    rows: evaluations,
-    deployment
-  });
-  assertRuntimeRowsMatchDeployment({
-    label: "lineage scope",
-    rows: storedLineageScopes,
-    deployment
-  });
-  return {
-    path: resolvedPath,
-    userName,
-    startTime,
-    endTime,
-    trades,
-    signals,
-    evaluations,
-    lineageScopes: storedLineageScopes.length ? storedLineageScopes : buildRuntimeEvidenceLineageScopes({ signals, evaluations }),
-    deployment
-  };
-};
-
-// src/lib/replay/support.ts
-var import_chalk8 = __toESM(require("chalk"));
-
-// src/lib/runtimeModeConfig.ts
-var buildRuntimeModeStrategyConfig = ({
-  strategyConfig,
-  env,
-  interval,
-  makeOrders,
-  recordRuntimeTrades,
-  aiReplayAnalyses
-}) => ({
-  ...strategyConfig,
-  ENV: env,
-  MAKE_ORDERS: makeOrders,
-  INTERVAL: strategyConfig.INTERVAL ?? interval,
-  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
-  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
-});
-
-// src/lib/replay/support.ts
-var REPLAY_RESULTS_BY_STRATEGY_HEADERS = [
-  import_chalk8.default.blue("STRATEGY"),
-  import_chalk8.default.yellow("TICKERS"),
-  import_chalk8.default.yellow("TRADE TICKERS"),
-  import_chalk8.default.cyan("ORDERS"),
-  import_chalk8.default.cyan("WIN/LOSS (%)"),
-  import_chalk8.default.cyan("PROFIT"),
-  import_chalk8.default.cyan("AVG TRADE")
-];
-var REPLAY_RUNTIME_COMPARISON_HEADERS = [
-  import_chalk8.default.blue("STRATEGY"),
-  import_chalk8.default.cyan("BT ENTRIES"),
-  import_chalk8.default.cyan("BT PNL"),
-  import_chalk8.default.yellow("RT TRADES"),
-  import_chalk8.default.yellow("RT PNL"),
-  import_chalk8.default.green("MATCHED"),
-  import_chalk8.default.red("ORDER FAILED"),
-  import_chalk8.default.yellow("RT ONLY"),
-  import_chalk8.default.magenta("BT ONLY"),
-  import_chalk8.default.red("UNMATCHED")
-];
-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;
-var formatReplayRuntimeCompareTolerance = () => `${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS} ${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS === 1 ? "bar" : "bars"}`;
-var getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly + row.backtestOnly;
-var buildReplayStrategyConfig = ({
-  strategyConfig,
-  interval
-}) => ({
-  ...buildRuntimeModeStrategyConfig({
-    strategyConfig,
-    env: "PARITY",
-    interval,
-    makeOrders: false,
-    recordRuntimeTrades: false
-  }),
-  SIMULATE_ORDERS: true
-});
-var toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var compactReplayAdditionalIndicators = (additionalIndicators) => {
-  const additional = toRecord(additionalIndicators);
-  if (!additional) {
-    return void 0;
-  }
-  const compact = {};
-  if (additional.executionSlippage != null) {
-    compact.executionSlippage = additional.executionSlippage;
-  }
-  if (additional.marketContext != null) {
-    compact.marketContext = additional.marketContext;
-  }
-  const baseContext = toRecord(additional.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const execution = toRecord(relative?.execution);
-  if (execution) {
-    compact.baseContext = {
-      relative: {
-        execution
-      }
-    };
-  }
-  return Object.keys(compact).length ? compact : void 0;
-};
-var compactReplaySignal = (signal) => {
-  if (!signal) {
-    return void 0;
+var loadReplayRuntimeEvidenceSource = async ({
+  filePath,
+  projectRoot,
+  expectedUserName,
+  expectedWindow
+}) => {
+  const { resolvedPath, runtime, userName, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot });
+  if (!userName || userName !== expectedUserName) {
+    throw new Error(
+      `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName || "missing"}`
+    );
+  }
+  const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
+  if (startTime !== expectedWindow.start || !endTimeMatches) {
+    throw new Error(
+      `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
+    );
   }
+  const trades = unwrapRows(runtime.trades, "trade");
+  const signals = unwrapRows(runtime.signals, "signal");
+  const evaluations = unwrapRows(
+    runtime.evaluations,
+    "evaluation"
+  );
+  const storedLineageScopes = unwrapRows(
+    runtime.lineageScopes,
+    "lineageScope"
+  );
+  assertRuntimeRowsMatchDeployment({
+    label: "trade",
+    rows: trades,
+    deployment
+  });
+  assertRuntimeRowsMatchDeployment({
+    label: "signal",
+    rows: signals,
+    deployment
+  });
+  assertRuntimeRowsMatchDeployment({
+    label: "evaluation",
+    rows: evaluations,
+    deployment
+  });
+  assertRuntimeRowsMatchDeployment({
+    label: "lineage scope",
+    rows: storedLineageScopes,
+    deployment
+  });
   return {
-    signalId: signal.signalId,
-    strategy: signal.strategy,
-    symbol: signal.symbol,
-    interval: signal.interval,
-    direction: signal.direction,
-    timestamp: signal.timestamp,
-    prices: signal.prices,
-    indicators: {},
-    figures: {},
-    additionalIndicators: compactReplayAdditionalIndicators(
-      signal.additionalIndicators
-    ),
-    isConfigFromBacktest: signal.isConfigFromBacktest,
-    ...signal.orderStatus ? { orderStatus: signal.orderStatus } : {},
-    ...signal.orderSkipReason ? { orderSkipReason: signal.orderSkipReason } : {},
-    ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
-    ...signal.ml ? { ml: signal.ml } : {}
+    path: resolvedPath,
+    userName,
+    startTime,
+    endTime,
+    trades,
+    signals,
+    evaluations,
+    lineageScopes: storedLineageScopes.length ? storedLineageScopes : buildRuntimeEvidenceLineageScopes({ signals, evaluations }),
+    deployment
   };
 };
 
@@ -4816,6 +5179,7 @@ var getPositionPnlSnapshot = ({
 var createPortfolioReplayConnector = (connector) => {
   let state = {};
   let amount = import_constants3.INITIAL_BACKTEST_AMOUNT;
+  let executionTimestamp = null;
   const positionsBySymbol = /* @__PURE__ */ new Map();
   const currentPriceBySymbol = /* @__PURE__ */ new Map();
   const orderLog = [];
@@ -5077,6 +5441,7 @@ var createPortfolioReplayConnector = (connector) => {
       });
       const nextPosition = {
         ...order,
+        timestamp: executionTimestamp ?? order.timestamp,
         price: entryPrice,
         signal: compactReplaySignal(order.signal),
         amount,
@@ -5101,6 +5466,7 @@ var createPortfolioReplayConnector = (connector) => {
         positionState,
         data: {
           ...order,
+          timestamp: executionTimestamp ?? order.timestamp,
           price: entryPrice,
           profit,
           fee,
@@ -5164,6 +5530,7 @@ var createPortfolioReplayConnector = (connector) => {
         positionState,
         data: {
           ...order,
+          timestamp: executionTimestamp ?? order.timestamp,
           price: executionPrice,
           qty: position.qty,
           profit,
@@ -5172,11 +5539,12 @@ var createPortfolioReplayConnector = (connector) => {
           ...getExecutionSlippageLogData(slippageBreakdown, "exit")
         }
       });
-      clearPosition(order.symbol, order.timestamp);
+      clearPosition(order.symbol, executionTimestamp ?? order.timestamp);
       return true;
     },
     getTickers: connector.getTickers,
     advanceMarket: async ({ symbol, candle }) => {
+      executionTimestamp = candle.timestamp;
       currentPriceBySymbol.set(symbol, candle.close);
       await checkSl({ symbol, candle });
       await checkTp({ symbol, candle });
@@ -5217,244 +5585,8 @@ var invokeAfterSignalsHooks = async (hooks, params) => {
   }
 };
 
-// src/lib/marketData/windows.ts
-var import_indicators2 = require("@tradejs/core/indicators");
-var splitCandlesForReplayWindow = (candles, start, preloadStart) => {
-  const prevData = [];
-  const replayData = [];
-  for (const candle of candles) {
-    if (candle.timestamp < preloadStart) {
-      continue;
-    }
-    if (candle.timestamp < start) {
-      prevData.push(candle);
-      continue;
-    }
-    replayData.push(candle);
-  }
-  return { prevData, replayData };
-};
-var alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
-
-// src/lib/replay/historicalSignalsReplayPreparation.ts
-var buildPreparedData = ({
-  data,
-  btcData,
-  ethData,
-  btcBinanceData,
-  btcCoinbaseData,
-  start,
-  preloadStart
-}) => {
-  const { prevData: prevDataRaw, replayData: replayDataRaw } = splitCandlesForReplayWindow(data, start, preloadStart);
-  const { prevData: btcPrevDataRaw, replayData: btcReplayDataRaw } = splitCandlesForReplayWindow(btcData, start, preloadStart);
-  const { prevData: ethPrevDataRaw, replayData: ethReplayDataRaw } = splitCandlesForReplayWindow(ethData, start, preloadStart);
-  const { prevData: btcBinancePrevDataRaw } = splitCandlesForReplayWindow(
-    btcBinanceData,
-    start,
-    preloadStart
-  );
-  const { prevData: btcCoinbasePrevDataRaw } = splitCandlesForReplayWindow(
-    btcCoinbaseData,
-    start,
-    preloadStart
-  );
-  const { alignedCoinCandles: prevData, alignedBtcCandles: btcPrevData } = alignSymbolWithBtcReference(prevDataRaw, btcPrevDataRaw);
-  const { alignedCoinCandles: replayData, alignedBtcCandles: btcReplayData } = alignSymbolWithBtcReference(replayDataRaw, btcReplayDataRaw);
-  const { alignedBtcCandles: ethPrevData } = alignSymbolWithBtcReference(
-    prevData,
-    ethPrevDataRaw
-  );
-  const { alignedBtcCandles: ethReplayData } = alignSymbolWithBtcReference(
-    replayData,
-    ethReplayDataRaw
-  );
-  const { alignedBtcCandles: btcBinancePrevData } = alignSymbolWithBtcReference(
-    prevDataRaw,
-    btcBinancePrevDataRaw
-  );
-  const { alignedBtcCandles: btcCoinbasePrevData } = alignSymbolWithBtcReference(prevDataRaw, btcCoinbasePrevDataRaw);
-  return {
-    prevData,
-    btcPrevData,
-    ethPrevData,
-    replayData,
-    btcReplayData,
-    ethReplayData,
-    btcBinancePrevData,
-    btcCoinbasePrevData
-  };
-};
-var strategyIncludesSymbol = (strategy, symbol) => {
-  const tickers = strategy.selection?.tickers;
-  if (!tickers) return true;
-  const normalizedSymbol = symbol.trim().toUpperCase();
-  return tickers.some(
-    (ticker) => ticker.trim().toUpperCase() === normalizedSymbol
-  );
-};
-var buildSymbolSharedReplayKey = ({
-  userName,
-  connectorName,
-  interval,
-  symbol,
-  start,
-  end
-}) => ["replay", userName, connectorName, symbol, interval, start, end].join(":");
-var prepareHistoricalReplay = async (context, adapters) => {
-  const {
-    userName,
-    projectRoot,
-    preparedRun,
-    interval,
-    connectorName,
-    replayConnector,
-    strategies,
-    references
-  } = context;
-  const symbolRuntimes = [];
-  const orderedTimestamps = /* @__PURE__ */ new Set();
-  const sharedReplayKeyPrefixes = [];
-  const runtimeLineages = [];
-  let skippedSymbols = 0;
-  for (const symbol of preparedRun.tickers) {
-    const data = await preparedRun.marketConnector.kline({
-      symbol,
-      start: preparedRun.preloadStart,
-      end: preparedRun.window.end,
-      cacheOnly: true,
-      interval
-    });
-    if (symbolRuntimes.length % 50 === 0)
-      adapters.sampleMemory?.("history:loaded", {
-        symbols: symbolRuntimes.length + 1,
-        candles: data.length
-      });
-    const preparedData = buildPreparedData({
-      data,
-      btcData: references.btcMarketData,
-      ethData: references.ethMarketData,
-      btcBinanceData: references.btcBinanceData,
-      btcCoinbaseData: references.btcCoinbaseData,
-      start: preparedRun.window.start,
-      preloadStart: preparedRun.preloadStart
-    });
-    if (!preparedData.replayData.length || !preparedData.btcReplayData.length) {
-      skippedSymbols += 1;
-      adapters.progress.tick({
-        skipped: adapters.display.skipped(skippedSymbols),
-        symbol: adapters.display.symbol(symbol)
-      });
-      continue;
-    }
-    const sharedIndicatorsReplayKey = buildSymbolSharedReplayKey({
-      userName,
-      connectorName,
-      interval,
-      symbol,
-      start: preparedRun.window.start,
-      end: preparedRun.window.end
-    });
-    sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
-    const strategiesForSymbol = await Promise.all(
-      strategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(async (strategy) => {
-        const replayStrategyConfig = buildReplayStrategyConfig({
-          strategyConfig: strategy.strategyConfig,
-          interval
-        });
-        const runtimeLineage = await adapters.buildLineage({
-          projectRoot,
-          strategyName: strategy.strategyName,
-          strategyRevision: strategy.strategyRevision,
-          deploymentCompositionId: strategy.deploymentCompositionId,
-          strategyPackageVersion: strategy.strategyPackageVersion,
-          strategyDependencyVersions: strategy.strategyDependencyVersions,
-          runtimePackageVersion: strategy.runtimePackageVersion,
-          config: {
-            configId: strategy.strategyRevision,
-            strategyConfig: strategy.strategyConfig,
-            symbolResultConfig: strategy.strategyResults?.[symbol]?.config ?? null
-          },
-          runContext: {
-            connectorName: connectorName.toLowerCase(),
-            interval: String(interval),
-            universe: preparedRun.universe ?? null
-          }
-        });
-        runtimeLineages.push({
-          strategy: strategy.strategyName,
-          symbol,
-          ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
-          ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
-          lineage: runtimeLineage
-        });
-        return {
-          strategyName: strategy.strategyName,
-          strategyConfig: strategy.strategyConfig,
-          runtimeLineage,
-          run: await strategy.strategyCreator({
-            userName,
-            connectorName,
-            runtimeConfigId: strategy.strategyRevision,
-            strategyRevision: strategy.strategyRevision,
-            runtimeLineage,
-            universe: preparedRun.universe,
-            accountId: preparedRun.accountId,
-            deploymentId: preparedRun.deploymentId,
-            runtimeConfigSnapshot: {
-              userConfig: replayStrategyConfig
-            },
-            config: replayStrategyConfig,
-            symbol,
-            data: preparedData.prevData,
-            btcData: preparedData.btcPrevData,
-            ethData: preparedData.ethPrevData,
-            btcBinanceData: preparedData.btcBinancePrevData,
-            btcCoinbaseData: preparedData.btcCoinbasePrevData,
-            connector: replayConnector,
-            sharedIndicatorsReplayKey
-          })
-        };
-      })
-    );
-    const symbolRuntime = {
-      symbol,
-      replayData: preparedData.replayData,
-      btcReplayData: preparedData.btcReplayData,
-      ethReplayData: preparedData.ethReplayData,
-      currentIndex: 0,
-      strategies: strategiesForSymbol
-    };
-    symbolRuntimes.push(symbolRuntime);
-    if (symbolRuntimes.length % 50 === 0 || symbol === preparedRun.tickers.at(-1))
-      adapters.sampleMemory?.("strategies:initializing", {
-        symbols: symbolRuntimes.length,
-        strategiesPerSymbol: strategiesForSymbol.length
-      });
-    adapters.progress.tick({
-      skipped: adapters.display.skipped(skippedSymbols),
-      symbol: adapters.display.symbol(symbol)
-    });
-    for (const candle of preparedData.replayData) {
-      orderedTimestamps.add(candle.timestamp);
-    }
-  }
-  return {
-    symbolRuntimes,
-    orderedTimestamps: [...orderedTimestamps].sort(
-      (left, right) => left - right
-    ),
-    sharedReplayKeyPrefixes,
-    runtimeLineages
-  };
-};
-var releaseHistoricalReplayPlan = (plan) => {
-  plan.symbolRuntimes.length = 0;
-  plan.sharedReplayKeyPrefixes.length = 0;
-};
-
 // src/lib/replay/historicalSignalsReplaySkipEvidence.ts
-var import_data = require("@tradejs/core/data");
+var import_data2 = require("@tradejs/core/data");
 var replayScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
 var appendReplaySignalEvaluationRun = ({
   runs = [],
@@ -5462,7 +5594,7 @@ var appendReplaySignalEvaluationRun = ({
   timestamp,
   interval
 }) => {
-  const stepMs = (0, import_data.intervalToMs)(interval);
+  const stepMs = (0, import_data2.intervalToMs)(interval);
   const last = runs.at(-1);
   if (last?.reason === reason && last.stepMs === stepMs && timestamp === last.lastTimestamp + stepMs) {
     return [...runs.slice(0, -1), { ...last, lastTimestamp: timestamp }];
@@ -5534,11 +5666,12 @@ var createHistoricalReplaySkipEvidence = (runtimeLineages, enabled = true) => {
 // src/lib/replay/historicalSignalsReplayExecution.ts
 var advanceCycleMarket = async (plan, connector, timestamp) => {
   const cycleSymbols = plan.symbolRuntimes.filter(
-    (symbolRuntime) => symbolRuntime.replayData[symbolRuntime.currentIndex]?.timestamp === timestamp
+    (symbolRuntime) => (symbolRuntime.replayData[symbolRuntime.currentIndex]?.timestamp ?? NaN) + (symbolRuntime.timestampOffsetMs ?? 0) === timestamp
   );
   for (const symbolRuntime of cycleSymbols) {
     const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
-    if (candle?.timestamp === timestamp) {
+    if (candle && candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) === timestamp) {
+      if (symbolRuntime.advanceMarket === false) continue;
       await connector.advanceMarket({
         symbol: symbolRuntime.symbol,
         candle
@@ -5550,7 +5683,7 @@ var advanceCycleMarket = async (plan, connector, timestamp) => {
 var advanceAbortedCycle = (cycleSymbols, timestamp) => {
   for (const symbolRuntime of cycleSymbols ?? []) {
     const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
-    if (candle?.timestamp === timestamp) {
+    if (candle && candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) === timestamp) {
       symbolRuntime.currentIndex += 1;
     }
   }
@@ -5599,21 +5732,21 @@ var executeHistoricalReplay = async (context, adapters) => {
         const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
         const btcCandle = symbolRuntime.btcReplayData[symbolRuntime.currentIndex];
         const ethCandle = symbolRuntime.ethReplayData[symbolRuntime.currentIndex];
-        if (!candle || !btcCandle || candle.timestamp !== timestamp || btcCandle.timestamp !== timestamp) {
+        if (!candle || !btcCandle || candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) !== timestamp || btcCandle.timestamp !== candle.timestamp) {
           continue;
         }
         for (const strategyRuntime of symbolRuntime.strategies) {
           const result = await strategyRuntime.run(
             candle,
             btcCandle,
-            ethCandle?.timestamp === timestamp ? ethCandle : void 0
+            ethCandle?.timestamp === candle.timestamp ? ethCandle : void 0
           );
           skipEvidence.record({
             strategyName: strategyRuntime.strategyName,
             symbol: symbolRuntime.symbol,
             strategyConfig: strategyRuntime.strategyConfig,
             runtimeLineage: strategyRuntime.runtimeLineage,
-            timestamp,
+            timestamp: candle.timestamp,
             result
           });
           if (result && typeof result !== "string") {
@@ -5634,10 +5767,7 @@ var executeHistoricalReplay = async (context, adapters) => {
       reportProgress(timestamp);
     }
   } finally {
-    for (const keyPrefix of context.plan.sharedReplayKeyPrefixes) {
-      adapters.releaseIndicatorsCache(keyPrefix);
-      adapters.releaseReplayCache(keyPrefix);
-    }
+    releaseHistoricalReplayCaches(context.plan, adapters);
   }
   return {
     signals,
@@ -5911,7 +6041,19 @@ var runHistoricalSignalsReplay = async ({
     }
   );
   memory?.("references:loaded");
-  const plan = await prepareHistoricalReplay(
+  const cacheAdapters = {
+    releaseIndicatorsCache: (keyPrefix) => releaseReplayCacheCopies(
+      keyPrefix,
+      import_strategies3.releaseStrategyIndicatorsReplayCache,
+      getProjectReplayCacheReleasers()?.releaseStrategyIndicatorsReplayCache
+    ),
+    releaseReplayCache: (keyPrefix) => releaseReplayCacheCopies(
+      keyPrefix,
+      import_strategies3.releaseStrategyReplayCache,
+      getProjectReplayCacheReleasers()?.releaseStrategyReplayCache
+    )
+  };
+  const plan = await prepareMultiIntervalHistoricalReplay(
     {
       userName: replayUserName,
       projectRoot: replayProjectRoot,
@@ -5928,6 +6070,7 @@ var runHistoricalSignalsReplay = async ({
       }
     },
     {
+      ...cacheAdapters,
       progress: {
         tick: (tokens) => prepareBar.tick(1, tokens)
       },
@@ -5937,7 +6080,11 @@ var runHistoricalSignalsReplay = async ({
       },
       buildLineage: buildRuntimeLineage,
       sampleMemory: memory
-    }
+    },
+    (nativeInterval, nativeRun) => loadHistoricalReplayReferences({
+      preparedRun: nativeRun,
+      interval: nativeInterval
+    })
   );
   memory?.("strategies:prepared", { symbols: plan.symbolRuntimes.length });
   const hookContext = buildAfterSignalsContext({
@@ -5964,6 +6111,7 @@ var runHistoricalSignalsReplay = async ({
       hookContext
     },
     {
+      ...cacheAdapters,
       clock: { now: Date.now },
       progress: {
         enabled: showProgress,
@@ -5976,17 +6124,7 @@ var runHistoricalSignalsReplay = async ({
       },
       invokeBeforeSignals: invokeBeforeSignalsHooks,
       invokeAfterSignals: invokeAfterSignalsHooks,
-      enrichSignal: (signal) => (0, import_strategies4.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" }),
-      releaseIndicatorsCache: (keyPrefix) => releaseReplayCacheCopies(
-        keyPrefix,
-        import_strategies3.releaseStrategyIndicatorsReplayCache,
-        getProjectReplayCacheReleasers()?.releaseStrategyIndicatorsReplayCache
-      ),
-      releaseReplayCache: (keyPrefix) => releaseReplayCacheCopies(
-        keyPrefix,
-        import_strategies3.releaseStrategyReplayCache,
-        getProjectReplayCacheReleasers()?.releaseStrategyReplayCache
-      )
+      enrichSignal: (signal) => (0, import_strategies4.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" })
     }
   );
   memory?.("execution:complete", { signals: execution.signals.length });
@@ -6446,6 +6584,7 @@ var saveAndPrintReplayResultsByStrategy = async ({
 
 // src/lib/replay/runtimeComparison.ts
 var import_chalk12 = __toESM(require("chalk"));
+var import_data4 = require("@tradejs/core/data");
 
 // src/lib/paritySummary.ts
 var summarizeRuntimeTradesByStrategy = (trades) => {
@@ -6524,7 +6663,7 @@ var import_redis4 = require("@tradejs/infra/redis");
 
 // src/lib/runtimeSignalsStorage.ts
 var import_constants5 = require("@tradejs/core/constants");
-var import_data2 = require("@tradejs/core/data");
+var import_data3 = require("@tradejs/core/data");
 var import_time4 = require("@tradejs/core/time");
 var isRuntimeSignalBucketRef = (value) => {
   if (!value || typeof value !== "object") {
@@ -8049,7 +8188,10 @@ var findExchangeRuntimeOutcome = ({
   return candidates.map((candidate) => ({
     ...candidate,
     timestampDiffMs: Math.abs(
-      candidate.timestamp + signalTimestampOffsetMs - exchangeEntry.entryTimestamp
+      candidate.timestamp + resolveTradeParityTimestampOffset(
+        strategyName,
+        signalTimestampOffsetMs
+      ) - exchangeEntry.entryTimestamp
     )
   })).filter((candidate) => candidate.timestampDiffMs <= toleranceMs).sort(
     (left, right) => left.timestampDiffMs - right.timestampDiffMs || Number(right.orderStatus === "failed") - Number(left.orderStatus === "failed")
@@ -8289,10 +8431,13 @@ var writeReplayComparisonReport = (lines) => {
 };
 
 // src/lib/replay/runtimeComparison.ts
-var getReplayEntryTimestampCompareOffsetMs = () => {
-  const intervalMinutes = Number(replayInterval);
-  return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 60 * 1e3 : 15 * 60 * 1e3;
-};
+var replayStrategyIntervals = (summaries) => summaries.map(({ strategyName, strategyConfig }) => {
+  const durationMs = (0, import_data4.intervalToMs)(strategyConfig.INTERVAL);
+  if (!Number.isFinite(durationMs) || durationMs <= 0) {
+    throw new Error(`Invalid replay interval for ${strategyName}`);
+  }
+  return { strategyName, interval: String(durationMs / 6e4) };
+});
 var buildReplaySignalEvaluations = (signals) => signals.map((signal) => ({
   evaluationId: `${signal.strategy}:${signal.symbol}:${signal.timestamp}`,
   userName: replayUserName,
@@ -8509,7 +8654,8 @@ var saveAndPrintReplayExchangeComparison = async ({
   runtimeSignals,
   runtimeSignalEvaluations,
   runtimeLineageScopes,
-  lineage
+  lineage,
+  timestampOffsetMs
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
   const rawExchangeEntries = await loadExchangeEntriesForComparison({
@@ -8534,7 +8680,7 @@ var saveAndPrintReplayExchangeComparison = async ({
       runtimeSignals,
       runtimeSignalEvaluations,
       toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-      signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+      signalTimestampOffsetMs: timestampOffsetMs
     });
   });
   const comparisonLineage = {
@@ -8556,7 +8702,7 @@ var saveAndPrintReplayExchangeComparison = async ({
       backtestEntries,
       strategyNameByOrderLinkKey,
       toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-      backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+      backtestTimestampOffsetMs: timestampOffsetMs,
       runtimeSignals,
       runtimeSignalEvaluations,
       replaySignals,
@@ -8595,7 +8741,7 @@ var saveAndPrintReplayExchangeComparison = async ({
     exchangeEntries,
     backtestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+    backtestTimestampOffsetMs: timestampOffsetMs
   });
   const { completed: matched, orderFailed } = splitExchangeMatchesByRuntimeOrderStatus({
     matched: comparison.matched,
@@ -8603,7 +8749,7 @@ var saveAndPrintReplayExchangeComparison = async ({
     runtimeSignals,
     runtimeSignalEvaluations,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+    signalTimestampOffsetMs: timestampOffsetMs
   });
   const details = buildReplayExchangeComparisonDetails({
     matched,
@@ -8614,7 +8760,7 @@ var saveAndPrintReplayExchangeComparison = async ({
     backtestEntries,
     strategyNameByOrderLinkKey,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+    backtestTimestampOffsetMs: timestampOffsetMs,
     runtimeSignals,
     runtimeSignalEvaluations,
     replaySignals,
@@ -8675,9 +8821,16 @@ var saveAndPrintReplayRuntimeComparison = async ({
     expectedUserName: replayUserName,
     expectedWindow: window
   }) : null;
-  const replayTimestampOffset = runtimeEvidence ? buildTradeParityTimestampOffset(
-    (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence.deployment)
-  ) : getReplayEntryTimestampCompareOffsetMs();
+  const declaredIntervals = runtimeEvidence ? [] : replayStrategyIntervals(liveStrategySummaries);
+  const replayTimestampOffset = buildTradeParityTimestampOffset(
+    runtimeEvidence ? (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence.deployment) : declaredIntervals
+  );
+  const metadataStart = runtimeEvidence ? window.start : window.start - Math.max(
+    0,
+    ...declaredIntervals.map(
+      ({ interval }) => Number(interval) * 6e4 - (0, import_data4.intervalToMs)(replayInterval)
+    )
+  );
   const [
     rawRuntimeTrades,
     runtimeSignals,
@@ -8694,15 +8847,15 @@ var saveAndPrintReplayRuntimeComparison = async ({
       endTime: window.end
     }),
     loadRuntimeSignals(replayUserName, {
-      startTime: window.start,
+      startTime: metadataStart,
       endTime: window.end
     }),
     loadRuntimeSignalEvaluations(replayUserName, {
-      startTime: window.start,
+      startTime: metadataStart,
       endTime: window.end
     }),
     loadRuntimeLineageScopes(replayUserName, {
-      startTime: window.start,
+      startTime: metadataStart,
       endTime: window.end
     })
   ]);
@@ -8770,6 +8923,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
     );
     return saveAndPrintReplayExchangeComparison({
       liveStrategySummaries,
+      timestampOffsetMs: replayTimestampOffset,
       backtestEntries: comparableBacktestEntries,
       replaySignals,
       replaySignalEvaluations,
@@ -9919,16 +10073,10 @@ var replayBacktest = async () => {
   if (!replayStrategies.length) {
     throw new Error(`No enabled strategies in deployment ${deployment.id}`);
   }
-  const strategyIntervals = new Set(
-    replayStrategies.map(
-      ({ strategyConfig }) => String(strategyConfig.INTERVAL)
-    )
+  resolveHistoricalReplayIntervals(
+    replayInterval,
+    replayStrategies.map(({ strategyConfig }) => strategyConfig.INTERVAL)
   );
-  if (strategyIntervals.size !== 1 || !strategyIntervals.has(replayInterval)) {
-    throw new Error(
-      `Replay interval does not match deployment ${deployment.id}: replay=${replayInterval}, strategies=${[...strategyIntervals].join(",")}`
-    );
-  }
   const strategyUniverses = new Set(
     replayStrategies.map(
       ({ strategyConfig }) => String(strategyConfig.UNIVERSE)
@@ -9974,13 +10122,13 @@ var replayBacktest = async () => {
     deploymentId: deployment.id,
     assetClasses: deployment.assetClasses,
     deployment,
-    closedIntervalMs: (0, import_data3.intervalToMs)(replayInterval)
+    closedIntervalMs: (0, import_data5.intervalToMs)(replayInterval)
   });
   if (!preparedRun || isReplayUpdateOnlyRun) {
     return;
   }
   if (useAllData) {
-    const intervalMs = (0, import_data3.intervalToMs)(replayInterval);
+    const intervalMs = (0, import_data5.intervalToMs)(replayInterval);
     const edges = await (0, import_candles.getDataEdgesForSymbols)(
       deployment.provider,
       preparedRun.tickers,