@tradejs/cli 3.1.26 → 3.1.27-beta.247

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_data2 = 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,6 +6529,7 @@ var import_redis4 = require("@tradejs/infra/redis");
 
 // src/lib/runtimeSignalsStorage.ts
 var import_constants4 = require("@tradejs/core/constants");
+var import_data2 = require("@tradejs/core/data");
 var import_time4 = require("@tradejs/core/time");
 var isRuntimeSignalBucketRef = (value) => {
   if (!value || typeof value !== "object") {
@@ -6988,6 +7078,90 @@ var findNearestEvaluation = ({
     timestampDiffMs: bestDiff
   } : null;
 };
+var findNearestRuntimeEvaluationOutcome = ({
+  entry,
+  lineageScopes,
+  toleranceMs
+}) => {
+  const strategy = getEntryStrategy(entry);
+  const timestamp = entry.signalTimestamp ?? entry.timestamp;
+  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 || timestamp < run.firstTimestamp - toleranceMs || timestamp > run.lastTimestamp + toleranceMs) {
+        continue;
+      }
+      const step = Math.round((timestamp - run.firstTimestamp) / run.stepMs);
+      const candidateTimestamp = run.firstTimestamp + step * run.stepMs;
+      const timestampDiffMs = Math.abs(candidateTimestamp - 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: "lineage_scope_compact"
+      };
+    }
+  }
+  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
+}) => {
+  const strategy = getEntryStrategy(entry);
+  const timestamp = entry.signalTimestamp ?? entry.timestamp;
+  return lineageScopes.some(
+    (scope) => scope.strategy === strategy && scope.symbol === entry.symbol && timestamp >= scope.firstTimestamp && timestamp <= scope.lastTimestamp
+  );
+};
 var classifySignalDiagnostic = (signal) => {
   if (signal.orderStatus === "failed") {
     return {
@@ -7232,6 +7406,8 @@ var buildReplayMismatchDrilldown = ({
   runtimeSignalEvaluations = [],
   replaySignals = [],
   replaySignalEvaluations = [],
+  replayLineageScopes = [],
+  runtimeLineageScopes = [],
   toleranceMs,
   backtestTimestampOffsetMs,
   limit
@@ -7257,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
     } : {
@@ -7281,7 +7466,8 @@ var buildReplayMismatchDrilldown = ({
           timestampDiffMs: nearestReplayEvaluation.timestampDiffMs
         }),
         ...includeArtifacts ? { replayEvaluationArtifact: nearestReplayEvaluation.evaluation } : {}
-      } : {}
+      } : {},
+      ...nearestReplayEvaluationOutcome ? { replayEvaluationOutcome: nearestReplayEvaluationOutcome } : {}
     };
   });
   const backtestOnlyDiagnostics = backtestOnly.map((entry, index) => {
@@ -7299,9 +7485,26 @@ var buildReplayMismatchDrilldown = ({
       toleranceMs,
       timestampOffsetMs: 0
     });
-    const classification = nearestRuntimeSignal ? classifySignalDiagnostic(nearestRuntimeSignal.signal) : nearestRuntimeEvaluation ? classifyEvaluationDiagnostic(nearestRuntimeEvaluation.evaluation) : nearestCandidate?.nearest ? {
+    const nearestRuntimeEvaluationOutcome = findNearestRuntimeEvaluationOutcome(
+      {
+        entry,
+        lineageScopes: runtimeLineageScopes,
+        toleranceMs
+      }
+    );
+    const runtimeLineageCoversEntry = hasRuntimeLineageCoverage({
+      entry,
+      lineageScopes: runtimeLineageScopes
+    });
+    const classification = nearestRuntimeSignal ? classifySignalDiagnostic(nearestRuntimeSignal.signal) : nearestRuntimeEvaluation ? classifyEvaluationDiagnostic(nearestRuntimeEvaluation.evaluation) : nearestRuntimeEvaluationOutcome ? {
+      classification: "core_skipped",
+      reason: nearestRuntimeEvaluationOutcome.reason
+    } : nearestCandidate?.nearest ? {
       classification: "timing_or_price_drift",
       reason: nearestCandidate.reason
+    } : runtimeLineageCoversEntry ? {
+      classification: "runtime_evaluation_detail_unavailable",
+      reason: "runtime_scope_covers_timestamp_but_skip_detail_was_not_stored"
     } : {
       classification: "no_runtime_evaluation",
       reason: "no_runtime_signal_or_evaluation"
@@ -7325,7 +7528,8 @@ var buildReplayMismatchDrilldown = ({
         ...includeArtifacts ? {
           runtimeEvaluationArtifact: nearestRuntimeEvaluation.evaluation
         } : {}
-      } : {}
+      } : {},
+      ...nearestRuntimeEvaluationOutcome ? { runtimeEvaluationOutcome: nearestRuntimeEvaluationOutcome } : {}
     };
   });
   for (const diagnostic of runtimeOnlyDiagnostics) {
@@ -7372,7 +7576,9 @@ var buildReplayRuntimeComparisonDetails = ({
   runtimeSignals,
   runtimeSignalEvaluations,
   replaySignals,
-  replaySignalEvaluations
+  replaySignalEvaluations,
+  replayLineageScopes,
+  runtimeLineageScopes
 }) => {
   const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
   const backtestDetails = backtestEntries.map(
@@ -7431,6 +7637,8 @@ var buildReplayRuntimeComparisonDetails = ({
       runtimeSignalEvaluations,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
+      runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
       limit
@@ -7451,7 +7659,9 @@ var buildReplayExchangeComparisonDetails = ({
   runtimeSignals,
   runtimeSignalEvaluations,
   replaySignals,
-  replaySignalEvaluations
+  replaySignalEvaluations,
+  replayLineageScopes,
+  runtimeLineageScopes
 }) => {
   const toExchangeDetail = (entry) => toExchangeParityDetail({
     entry,
@@ -7538,6 +7748,8 @@ var buildReplayExchangeComparisonDetails = ({
       runtimeSignalEvaluations,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
+      runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
       limit
@@ -7660,19 +7872,41 @@ 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,
     runtimeSignals: comparableRuntimeSignals,
     runtimeSignalEvaluations: comparableRuntimeEvaluations,
+    runtimeLineageScopes: comparableRuntimeLineageScopes,
     backtestEntries: comparableBacktestEntries,
     lineage: {
       enforced: true,
@@ -7684,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("::");
@@ -8267,8 +8502,10 @@ var saveAndPrintReplayExchangeComparison = async ({
   backtestEntries,
   replaySignals,
   replaySignalEvaluations,
+  replayLineageScopes,
   runtimeSignals,
   runtimeSignalEvaluations,
+  runtimeLineageScopes,
   lineage
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -8320,7 +8557,9 @@ var saveAndPrintReplayExchangeComparison = async ({
       runtimeSignals,
       runtimeSignalEvaluations,
       replaySignals,
-      replaySignalEvaluations
+      replaySignalEvaluations,
+      runtimeLineageScopes,
+      replayLineageScopes
     });
     const emptyRowsByStrategy = new Map(
       buildExchangeComparisonRows({
@@ -8376,7 +8615,9 @@ var saveAndPrintReplayExchangeComparison = async ({
     runtimeSignals,
     runtimeSignalEvaluations,
     replaySignals,
-    replaySignalEvaluations
+    replaySignalEvaluations,
+    runtimeLineageScopes,
+    replayLineageScopes
   });
   const rows = buildExchangeComparisonRows({
     liveStrategySummaries,
@@ -8414,6 +8655,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   backtestEntries,
   replaySignals,
   replayLineages,
+  replayLineageScopes,
   runtimeEvidencePath
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -8525,8 +8767,10 @@ var saveAndPrintReplayRuntimeComparison = async ({
       backtestEntries: comparableBacktestEntries,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
       runtimeSignals: comparable.runtimeSignals,
       runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
+      runtimeLineageScopes: comparable.runtimeLineageScopes,
       lineage: comparable.lineage
     });
   }
@@ -8550,7 +8794,9 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeSignals: comparable.runtimeSignals,
     runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
     replaySignals,
-    replaySignalEvaluations
+    replaySignalEvaluations,
+    runtimeLineageScopes: comparable.runtimeLineageScopes,
+    replayLineageScopes
   });
   const parityRows = summarizeTradeParityByStrategy({
     runtimeEntries: runtimeDedupe.entries,
@@ -8593,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_data = 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",
@@ -9000,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_data.toJson)(report, true)}
+    import_promises2.default.writeFile(jsonPath, `${(0, import_data3.toJson)(report, true)}
 `, "utf8")
   ]);
   return {
@@ -9042,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();
@@ -9208,7 +9455,7 @@ var replayBacktest = async () => {
     deploymentId: deployment.id,
     assetClasses: deployment.assetClasses,
     deployment,
-    closedIntervalMs: (0, import_data2.intervalToMs)(replayInterval)
+    closedIntervalMs: (0, import_data4.intervalToMs)(replayInterval)
   });
   if (!preparedRun || isReplayUpdateOnlyRun) {
     return;