@tradejs/cli 3.1.27-beta.245 → 3.1.27-beta.248

package/dist/scripts/replay.js

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(replay_exports);
 // src/scripts/replayRunner.ts
 var import_chalk13 = __toESM(require("chalk"));
 var import_constants6 = require("@tradejs/core/constants");
-var import_data3 = require("@tradejs/core/data");
+var import_data4 = require("@tradejs/core/data");
 var import_time7 = require("@tradejs/core/time");
 var import_redis6 = require("@tradejs/infra/redis");
 
@@ -5611,6 +5611,78 @@ var prepareHistoricalReplay = async (context, adapters) => {
   };
 };
 
+// src/lib/replay/historicalSignalsReplaySkipEvidence.ts
+var import_data = require("@tradejs/core/data");
+var replayScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
+var appendReplaySignalEvaluationRun = ({
+  runs = [],
+  reason,
+  timestamp,
+  interval
+}) => {
+  const stepMs = (0, import_data.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 }];
+  }
+  return [
+    ...runs,
+    {
+      status: "skip",
+      reason,
+      firstTimestamp: timestamp,
+      lastTimestamp: timestamp,
+      stepMs
+    }
+  ];
+};
+var createHistoricalReplaySkipEvidence = (runtimeLineages) => {
+  const lineageByStrategySymbol = new Map(
+    runtimeLineages.map((record2) => [
+      replayScopeKey(record2.strategy, record2.symbol),
+      record2
+    ])
+  );
+  const scopes = /* @__PURE__ */ new Map();
+  const record = ({
+    strategyName,
+    symbol,
+    strategyConfig,
+    runtimeLineage,
+    timestamp,
+    result
+  }) => {
+    const scopeKey = replayScopeKey(strategyName, symbol);
+    const lineageRecord = lineageByStrategySymbol.get(scopeKey);
+    if (!lineageRecord) return;
+    const existing = scopes.get(scopeKey);
+    const skipReason = typeof result === "string" ? result.trim() || "NO_SIGNAL" : result ? null : "NO_SIGNAL";
+    scopes.set(scopeKey, {
+      strategy: strategyName,
+      symbol,
+      ...lineageRecord.deploymentId ? { deploymentId: lineageRecord.deploymentId } : {},
+      ...lineageRecord.accountId ? { accountId: lineageRecord.accountId } : {},
+      strategyRevision: runtimeLineage.strategyRevision,
+      lineage: runtimeLineage,
+      firstTimestamp: Math.min(
+        existing?.firstTimestamp ?? timestamp,
+        timestamp
+      ),
+      lastTimestamp: Math.max(existing?.lastTimestamp ?? timestamp, timestamp),
+      evaluationRuns: skipReason ? appendReplaySignalEvaluationRun({
+        runs: existing?.evaluationRuns,
+        reason: skipReason,
+        timestamp,
+        interval: strategyConfig.INTERVAL ?? "15"
+      }) : existing?.evaluationRuns
+    });
+  };
+  const values = () => [...scopes.values()].sort(
+    (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol)
+  );
+  return { record, values };
+};
+
 // src/lib/replay/historicalSignalsReplayExecution.ts
 var advanceCycleMarket = async (plan, connector, timestamp) => {
   const cycleSymbols = plan.cycleSymbolsByTimestamp.get(timestamp) ?? [];
@@ -5636,6 +5708,9 @@ var advanceAbortedCycle = (cycleSymbols, timestamp) => {
 var executeHistoricalReplay = async (context, adapters) => {
   const signals = [];
   let abortedCycles = 0;
+  const skipEvidence = createHistoricalReplaySkipEvidence(
+    context.plan.runtimeLineages
+  );
   try {
     for (const timestamp of context.plan.orderedTimestamps) {
       const cycleStartedAt = adapters.clock.now();
@@ -5678,6 +5753,14 @@ var executeHistoricalReplay = async (context, adapters) => {
             btcCandle,
             ethCandle?.timestamp === timestamp ? ethCandle : void 0
           );
+          skipEvidence.record({
+            strategyName: strategyRuntime.strategyName,
+            symbol: symbolRuntime.symbol,
+            strategyConfig: strategyRuntime.strategyConfig,
+            runtimeLineage: strategyRuntime.runtimeLineage,
+            timestamp,
+            result
+          });
           if (result && typeof result !== "string") {
             result.runtimeLineage = strategyRuntime.runtimeLineage;
             await adapters.enrichSignal(result);
@@ -5705,7 +5788,11 @@ var executeHistoricalReplay = async (context, adapters) => {
       adapters.releaseReplayCache(keyPrefix);
     }
   }
-  return { signals, abortedCycles };
+  return {
+    signals,
+    abortedCycles,
+    replayLineageScopes: skipEvidence.values()
+  };
 };
 
 // src/lib/replay/historicalSignalsReplayResults.ts
@@ -5734,7 +5821,8 @@ var collectHistoricalReplayResult = (context) => ({
   positionLog: context.artifacts.positionLog,
   cycleCount: context.cycleCount,
   abortedCycles: context.abortedCycles,
-  runtimeLineages: context.runtimeLineages
+  runtimeLineages: context.runtimeLineages,
+  replayLineageScopes: context.replayLineageScopes
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
@@ -5953,7 +6041,8 @@ var runHistoricalSignalsReplay = async ({
     signals: execution.signals,
     cycleCount: plan.orderedTimestamps.length,
     abortedCycles: execution.abortedCycles,
-    runtimeLineages: plan.runtimeLineages
+    runtimeLineages: plan.runtimeLineages,
+    replayLineageScopes: execution.replayLineageScopes
   });
 };
 
@@ -6440,7 +6529,7 @@ var import_redis4 = require("@tradejs/infra/redis");
 
 // src/lib/runtimeSignalsStorage.ts
 var import_constants4 = require("@tradejs/core/constants");
-var import_data = require("@tradejs/core/data");
+var import_data2 = require("@tradejs/core/data");
 var import_time4 = require("@tradejs/core/time");
 var isRuntimeSignalBucketRef = (value) => {
   if (!value || typeof value !== "object") {
@@ -7023,6 +7112,46 @@ var findNearestRuntimeEvaluationOutcome = ({
   }
   return nearest;
 };
+var findNearestReplayEvaluationOutcome = ({
+  entry,
+  lineageScopes,
+  toleranceMs,
+  timestampOffsetMs
+}) => {
+  const strategy = getEntryStrategy(entry);
+  if (!strategy) return null;
+  let nearest = null;
+  for (const scope of lineageScopes) {
+    if (scope.strategy !== strategy || scope.symbol !== entry.symbol) {
+      continue;
+    }
+    for (const run of scope.evaluationRuns ?? []) {
+      if (run.stepMs <= 0) continue;
+      const targetTimestamp = entry.timestamp - timestampOffsetMs;
+      if (targetTimestamp < run.firstTimestamp - toleranceMs || targetTimestamp > run.lastTimestamp + toleranceMs) {
+        continue;
+      }
+      const step = Math.round(
+        (targetTimestamp - run.firstTimestamp) / run.stepMs
+      );
+      const candidateTimestamp = run.firstTimestamp + step * run.stepMs;
+      const timestampDiffMs = Math.abs(
+        candidateTimestamp + timestampOffsetMs - entry.timestamp
+      );
+      if (candidateTimestamp < run.firstTimestamp || candidateTimestamp > run.lastTimestamp || timestampDiffMs > toleranceMs || nearest && timestampDiffMs >= nearest.timestampDiffMs) {
+        continue;
+      }
+      nearest = {
+        status: run.status,
+        reason: run.reason,
+        timestamp: candidateTimestamp,
+        timestampDiffMs,
+        source: "replay_scope_compact"
+      };
+    }
+  }
+  return nearest;
+};
 var hasRuntimeLineageCoverage = ({
   entry,
   lineageScopes
@@ -7277,6 +7406,7 @@ var buildReplayMismatchDrilldown = ({
   runtimeSignalEvaluations = [],
   replaySignals = [],
   replaySignalEvaluations = [],
+  replayLineageScopes = [],
   runtimeLineageScopes = [],
   toleranceMs,
   backtestTimestampOffsetMs,
@@ -7303,7 +7433,16 @@ var buildReplayMismatchDrilldown = ({
       toleranceMs,
       timestampOffsetMs: backtestTimestampOffsetMs
     });
-    const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestCandidate?.nearest ? {
+    const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
+      entry,
+      lineageScopes: replayLineageScopes,
+      toleranceMs,
+      timestampOffsetMs: backtestTimestampOffsetMs
+    });
+    const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
+      classification: "core_skipped",
+      reason: nearestReplayEvaluationOutcome.reason
+    } : nearestCandidate?.nearest ? {
       classification: "timing_or_price_drift",
       reason: nearestCandidate.reason
     } : {
@@ -7327,7 +7466,8 @@ var buildReplayMismatchDrilldown = ({
           timestampDiffMs: nearestReplayEvaluation.timestampDiffMs
         }),
         ...includeArtifacts ? { replayEvaluationArtifact: nearestReplayEvaluation.evaluation } : {}
-      } : {}
+      } : {},
+      ...nearestReplayEvaluationOutcome ? { replayEvaluationOutcome: nearestReplayEvaluationOutcome } : {}
     };
   });
   const backtestOnlyDiagnostics = backtestOnly.map((entry, index) => {
@@ -7437,6 +7577,7 @@ var buildReplayRuntimeComparisonDetails = ({
   runtimeSignalEvaluations,
   replaySignals,
   replaySignalEvaluations,
+  replayLineageScopes,
   runtimeLineageScopes
 }) => {
   const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
@@ -7496,6 +7637,7 @@ var buildReplayRuntimeComparisonDetails = ({
       runtimeSignalEvaluations,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
       runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
@@ -7518,6 +7660,7 @@ var buildReplayExchangeComparisonDetails = ({
   runtimeSignalEvaluations,
   replaySignals,
   replaySignalEvaluations,
+  replayLineageScopes,
   runtimeLineageScopes
 }) => {
   const toExchangeDetail = (entry) => toExchangeParityDetail({
@@ -7605,6 +7748,7 @@ var buildReplayExchangeComparisonDetails = ({
       runtimeSignalEvaluations,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
       runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
@@ -7728,14 +7872,35 @@ var filterReplayComparisonByLineage = ({
       lineageScopeKey(record)
     ])
   );
-  const comparableBacktestEntries = backtestEntries.filter((entry) => {
+  const comparableBacktestEntries = [];
+  const excludedBacktestEntryDetails = [];
+  for (const entry of backtestEntries) {
     const replayScope = replayScopeByStrategySymbol.get(
       `${entry.strategy}::${entry.symbol}`
     );
     const window = replayScope ? deploymentWindows.get(replayScope) : null;
     const signalTimestamp = entry.signalTimestamp ?? entry.timestamp;
-    return window != null && signalTimestamp >= window.firstTimestamp && signalTimestamp <= window.lastTimestamp;
-  });
+    if (window != null && signalTimestamp >= window.firstTimestamp && signalTimestamp <= window.lastTimestamp) {
+      comparableBacktestEntries.push(entry);
+      continue;
+    }
+    const reason = !replayScope ? "replay_scope_missing" : !window ? "runtime_scope_missing" : signalTimestamp < window.firstTimestamp ? "before_runtime_window" : "after_runtime_window";
+    excludedBacktestEntryDetails.push({
+      id: entry.id,
+      strategy: entry.strategy,
+      symbol: entry.symbol,
+      direction: entry.direction,
+      ...entry.qty != null ? { qty: entry.qty } : {},
+      timestamp: entry.timestamp,
+      ...entry.signalTimestamp != null ? { signalTimestamp: entry.signalTimestamp } : {},
+      price: entry.price,
+      ...entry.orderId ? { orderId: entry.orderId } : {},
+      ...entry.signalId ? { signalId: entry.signalId } : {},
+      ...entry.expectedPnl != null ? { expectedPnl: entry.expectedPnl } : {},
+      reason,
+      runtimeWindow: window ?? null
+    });
+  }
   const comparableScopeKeys = new Set(deploymentWindows.keys());
   return {
     runtimeTrades: comparableRuntimeTrades,
@@ -7753,6 +7918,7 @@ var filterReplayComparisonByLineage = ({
       excludedRuntimeLineageScopes: runtimeLineageScopes.length - comparableRuntimeLineageScopes.length,
       excludedExchangeEntries: 0,
       excludedBacktestEntries: backtestEntries.length - comparableBacktestEntries.length,
+      excludedBacktestEntryDetails,
       reason: comparableScopeKeys.size > 0 ? null : expectedByScope.size === 0 ? "replay_produced_no_lineage_scopes" : "no_runtime_artifacts_with_matching_lineage",
       replay: [...expectedByScope.entries()].map(([scope, lineage]) => {
         const [deploymentId, accountId, strategy, symbol] = scope.split("::");
@@ -8336,6 +8502,7 @@ var saveAndPrintReplayExchangeComparison = async ({
   backtestEntries,
   replaySignals,
   replaySignalEvaluations,
+  replayLineageScopes,
   runtimeSignals,
   runtimeSignalEvaluations,
   runtimeLineageScopes,
@@ -8391,7 +8558,8 @@ var saveAndPrintReplayExchangeComparison = async ({
       runtimeSignalEvaluations,
       replaySignals,
       replaySignalEvaluations,
-      runtimeLineageScopes
+      runtimeLineageScopes,
+      replayLineageScopes
     });
     const emptyRowsByStrategy = new Map(
       buildExchangeComparisonRows({
@@ -8448,7 +8616,8 @@ var saveAndPrintReplayExchangeComparison = async ({
     runtimeSignalEvaluations,
     replaySignals,
     replaySignalEvaluations,
-    runtimeLineageScopes
+    runtimeLineageScopes,
+    replayLineageScopes
   });
   const rows = buildExchangeComparisonRows({
     liveStrategySummaries,
@@ -8486,6 +8655,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   backtestEntries,
   replaySignals,
   replayLineages,
+  replayLineageScopes,
   runtimeEvidencePath
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -8597,6 +8767,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
       backtestEntries: comparableBacktestEntries,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
       runtimeSignals: comparable.runtimeSignals,
       runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
       runtimeLineageScopes: comparable.runtimeLineageScopes,
@@ -8624,7 +8795,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
     replaySignals,
     replaySignalEvaluations,
-    runtimeLineageScopes: comparable.runtimeLineageScopes
+    runtimeLineageScopes: comparable.runtimeLineageScopes,
+    replayLineageScopes
   });
   const parityRows = summarizeTradeParityByStrategy({
     runtimeEntries: runtimeDedupe.entries,
@@ -8667,7 +8839,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
 // src/lib/replay/outputReport.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
-var import_data2 = require("@tradejs/core/data");
+var import_data3 = require("@tradejs/core/data");
 var formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
   timeZone: "Europe/Moscow",
   dateStyle: "short",
@@ -9074,7 +9246,7 @@ var writeReplayOutputReport = async ({
   ];
   await Promise.all([
     import_promises2.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-    import_promises2.default.writeFile(jsonPath, `${(0, import_data2.toJson)(report, true)}
+    import_promises2.default.writeFile(jsonPath, `${(0, import_data3.toJson)(report, true)}
 `, "utf8")
   ]);
   return {
@@ -9116,6 +9288,7 @@ var finishReplay = async ({
     backtestEntries: replayStrategySnapshot.backtestEntries,
     replaySignals: replayResult.signals,
     replayLineages: replayResult.runtimeLineages,
+    replayLineageScopes: replayResult.replayLineageScopes,
     runtimeEvidencePath: replayRuntimeEvidencePath
   });
   const finishedAt = /* @__PURE__ */ new Date();
@@ -9282,7 +9455,7 @@ var replayBacktest = async () => {
     deploymentId: deployment.id,
     assetClasses: deployment.assetClasses,
     deployment,
-    closedIntervalMs: (0, import_data3.intervalToMs)(replayInterval)
+    closedIntervalMs: (0, import_data4.intervalToMs)(replayInterval)
   });
   if (!preparedRun || isReplayUpdateOnlyRun) {
     return;