@tradejs/cli 3.1.26 → 3.1.27-beta.247

package/dist/cli.js

@@ -24004,12 +24004,43 @@ var init_results = __esm({
 });
 
 // src/lib/runtimeSignalsStorage.ts
-var import_constants14, import_time6, SECONDS_PER_DAY, RUNTIME_SIGNAL_RETENTION_DAYS_ENV, DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS, RUNTIME_LINEAGE_SCOPE_RETENTION_TTL_SECONDS, parsePositiveNumber, getRuntimeSignalRetentionTtlSeconds, toRuntimeSignalBucketRef, shouldStoreRuntimeSignalDiagnostics, toStoredRuntimeSignal, isRuntimeSignalBucketRef, normalizeRuntimeSignalSkipReason, buildStatsReasonField, buildRuntimeSignalStatsIncrements, shouldStoreDetailedRuntimeSignalEvaluation, toCount, parseRuntimeSignalStatsBucket;
+var import_constants14, import_data4, import_time6, appendRuntimeSignalEvaluationRun, SECONDS_PER_DAY, RUNTIME_SIGNAL_RETENTION_DAYS_ENV, DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS, RUNTIME_LINEAGE_SCOPE_RETENTION_TTL_SECONDS, parsePositiveNumber, getRuntimeSignalRetentionTtlSeconds, toRuntimeSignalBucketRef, shouldStoreRuntimeSignalDiagnostics, toStoredRuntimeSignal, isRuntimeSignalBucketRef, normalizeRuntimeSignalSkipReason, buildStatsReasonField, buildRuntimeSignalStatsIncrements, shouldStoreDetailedRuntimeSignalEvaluation, toCount, parseRuntimeSignalStatsBucket;
 var init_runtimeSignalsStorage = __esm({
   "src/lib/runtimeSignalsStorage.ts"() {
     "use strict";
     import_constants14 = require("@tradejs/core/constants");
+    import_data4 = require("@tradejs/core/data");
     import_time6 = require("@tradejs/core/time");
+    appendRuntimeSignalEvaluationRun = (runs = [], evaluation) => {
+      if (evaluation.status !== "skip") {
+        return [...runs];
+      }
+      const stepMs = (0, import_data4.intervalToMs)(evaluation.interval);
+      const reason = evaluation.reason?.trim() || "NO_SIGNAL";
+      const existing = runs.find(
+        (run) => run.status === "skip" && run.reason === reason && run.stepMs === stepMs && evaluation.timestamp >= run.firstTimestamp && evaluation.timestamp <= run.lastTimestamp && (evaluation.timestamp - run.firstTimestamp) % stepMs === 0
+      );
+      if (existing) {
+        return [...runs];
+      }
+      const last = runs.at(-1);
+      if (last?.status === "skip" && last.reason === reason && last.stepMs === stepMs && evaluation.timestamp === last.lastTimestamp + stepMs) {
+        return [
+          ...runs.slice(0, -1),
+          { ...last, lastTimestamp: evaluation.timestamp }
+        ];
+      }
+      return [
+        ...runs,
+        {
+          status: "skip",
+          reason,
+          firstTimestamp: evaluation.timestamp,
+          lastTimestamp: evaluation.timestamp,
+          stepMs
+        }
+      ];
+    };
     SECONDS_PER_DAY = 86400;
     RUNTIME_SIGNAL_RETENTION_DAYS_ENV = "RUNTIME_SIGNAL_RETENTION_DAYS";
     DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS = import_constants14.TTL_3D;
@@ -24862,9 +24893,21 @@ var init_replayRuntimeEvidence = __esm({
       const replayLineage = asArray2(comparisonLineage.replay).filter(
         (entry) => !useFilter || strategySet.has(String(asRecord4(entry).strategy ?? ""))
       );
+      const hasExcludedBacktestEntryDetails = Array.isArray(
+        comparisonLineage.excludedBacktestEntryDetails
+      );
+      const excludedBacktestEntryDetails = asArray2(
+        comparisonLineage.excludedBacktestEntryDetails
+      ).filter(
+        (entry) => !useFilter || strategySet.has(String(asRecord4(entry).strategy ?? ""))
+      );
       return {
         mode: comparison.mode ?? null,
-        lineage: comparisonLineage ? { ...comparisonLineage, replay: replayLineage } : null,
+        lineage: comparisonLineage ? {
+          ...comparisonLineage,
+          replay: replayLineage,
+          ...hasExcludedBacktestEntryDetails ? { excludedBacktestEntryDetails } : {}
+        } : null,
         rows: asArray2(comparison.rows).filter(
           (row) => !useFilter || strategySet.has(String(row.strategyName ?? ""))
         ),
@@ -26960,7 +27003,7 @@ var init_runtimeEvidenceSync2 = __esm({
 });
 
 // src/lib/runtimeScorecard.ts
-var asRecord6, asArray3, finiteNumber5, finiteString2, packageVersionMap, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildEmbeddedLineageScope, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, buildDistributions, buildDistributionDelta, sum2, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
+var asRecord6, asArray3, finiteNumber5, finiteString2, packageVersionMap, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildEmbeddedLineageScope, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, resolveGateDecision, buildDistributions, buildDistributionDelta, sum2, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
 var init_runtimeScorecard = __esm({
   "src/lib/runtimeScorecard.ts"() {
     "use strict";
@@ -27180,6 +27223,20 @@ var init_runtimeScorecard = __esm({
         Object.entries(counts).sort(([left], [right]) => left.localeCompare(right))
       );
     };
+    resolveGateDecision = (evaluation) => {
+      const analysis = asRecord6(evaluation.aiAnalysis);
+      const explicit = finiteString2(analysis?.gateDecision);
+      if (explicit === "approved" || explicit === "rejected") {
+        return { decision: explicit, source: "gate_decision" };
+      }
+      if (typeof analysis?.approved === "boolean") {
+        return {
+          decision: analysis.approved ? "approved" : "rejected",
+          source: "legacy_approved_fallback"
+        };
+      }
+      return null;
+    };
     buildDistributions = ({
       evaluations,
       signals: signals2
@@ -27360,18 +27417,15 @@ var init_runtimeScorecard = __esm({
       const signalEvaluations = rows.evaluations.filter(
         (evaluation) => evaluation.status === "signal"
       );
-      const gateDecisions = signalEvaluations.map((evaluation) => ({
-        evaluation,
-        decision: finiteString2(asRecord6(evaluation.aiAnalysis)?.gateDecision)
-      })).filter(
-        ({ decision }) => decision === "approved" || decision === "rejected"
+      const gateDecisions = signalEvaluations.map(resolveGateDecision).filter(
+        (decision) => Boolean(decision)
       );
       const llmEligibleEvaluations = llmComparatorPolicy === "disabled" ? [] : llmComparatorPolicy === "ai_approved_only" ? signalEvaluations.filter(
-        (evaluation) => finiteString2(asRecord6(evaluation.aiAnalysis)?.gateDecision) === "approved"
+        (evaluation) => resolveGateDecision(evaluation)?.decision === "approved"
       ) : signalEvaluations;
       const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
         const analysis = asRecord6(evaluation.aiAnalysis);
-        const gateDecision = finiteString2(analysis?.gateDecision);
+        const gateDecision = resolveGateDecision(evaluation)?.decision ?? null;
         const llmDecision = finiteString2(analysis?.llmDecision);
         if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
           return null;
@@ -27406,6 +27460,27 @@ var init_runtimeScorecard = __esm({
       };
       const actualSlippageBps = averageSampleMetric("signalToFillAdverseBps");
       const residualVsModelBps = averageSampleMetric("residualVsCurrentModelBps");
+      const signalToArrivalAdverseBps = averageSampleMetric(
+        "signalToArrivalAdverseBps"
+      );
+      const arrivalToFillAdverseBps = averageSampleMetric(
+        "arrivalToFillAdverseBps"
+      );
+      const averageSignalCloseToSubmitMs = averageSampleMetric(
+        "signalCloseToSubmitMs"
+      );
+      const averageSubmitToFillMs = averageSampleMetric("submitToFillMs");
+      const fullTelemetryTrades = calibrationSamples.filter(
+        (sample) => finiteString2(sample.telemetryQuality) === "full"
+      ).length;
+      const arrivalQuoteTrades = calibrationSamples.filter(
+        (sample) => finiteNumber5(sample.arrivalMid) != null
+      ).length;
+      const arrivalQuoteCoverage = calibrationSamples.length ? round(arrivalQuoteTrades / calibrationSamples.length) : null;
+      const hasTelemetryQuality = calibrationSamples.some(
+        (sample) => finiteString2(sample.telemetryQuality) != null
+      );
+      const maximumSignalCloseToSubmitMs = thresholds.maximumSignalCloseToSubmitMs ?? 3e4;
       const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
       const historyTrades = dedupeTrades([
         ...scopedHistoryArtifacts,
@@ -27462,7 +27537,28 @@ var init_runtimeScorecard = __esm({
         reactions.push({
           code: "SLIPPAGE_DRIFT",
           severity: "warning",
-          message: `Execution residual ${round(residualVsModelBps, 2)} bps exceeds ${thresholds.maximumSlippageResidualBps} bps.`
+          message: `Signal-close-to-fill residual ${round(residualVsModelBps, 2)} bps exceeds ${thresholds.maximumSlippageResidualBps} bps.`
+        });
+      }
+      if (averageSignalCloseToSubmitMs != null && averageSignalCloseToSubmitMs > maximumSignalCloseToSubmitMs) {
+        reactions.push({
+          code: "PRE_SUBMIT_LATENCY",
+          severity: "warning",
+          message: `Average signal-close-to-submit latency ${round(averageSignalCloseToSubmitMs, 3)} ms exceeds ${maximumSignalCloseToSubmitMs} ms.`
+        });
+      }
+      if (hasTelemetryQuality && calibrationSamples.length > 0 && fullTelemetryTrades < calibrationSamples.length) {
+        reactions.push({
+          code: "EXECUTION_TELEMETRY_INCOMPLETE",
+          severity: "info",
+          message: `Full arrival and fill telemetry is available for ${fullTelemetryTrades}/${calibrationSamples.length} trades.`
+        });
+      }
+      if (riskDecisions.some((decision) => decision.status === "rejected")) {
+        reactions.push({
+          code: "RISK_PLAN_EXCEEDS_DECLARED_LIMIT",
+          severity: "warning",
+          message: "At least one observed order plan exceeds its declared MAX_LOSS_VALUE; telemetry is not yet enforced."
         });
       }
       if (sevenDay.closedTrades >= thresholds.minimumClosedTrades && sevenDay.expectancy != null && sevenDay.expectancy < thresholds.minimumExpectancy) {
@@ -27491,7 +27587,10 @@ var init_runtimeScorecard = __esm({
         deployment: deploymentBinding,
         lineage: runtimeLineage,
         promotionStatus,
-        thresholds,
+        thresholds: {
+          ...thresholds,
+          maximumSignalCloseToSubmitMs
+        },
         funnel: {
           evaluations: rows.evaluations.length,
           coreCandidates: signalEvaluations.length,
@@ -27503,25 +27602,38 @@ var init_runtimeScorecard = __esm({
             rejected: gateDecisions.filter(
               ({ decision }) => decision === "rejected"
             ).length,
-            coverage: signalEvaluations.length ? round(gateDecisions.length / signalEvaluations.length) : null
+            coverage: signalEvaluations.length ? round(gateDecisions.length / signalEvaluations.length) : null,
+            legacyApprovedFallback: gateDecisions.filter(
+              ({ source }) => source === "legacy_approved_fallback"
+            ).length
           },
           allocator: {
             available: allocatorDecisions.length > 0,
             approved: allocatorDecisions.filter(
-              (decision) => decision.decision === "approved"
+              (decision) => decision.status === "approved"
             ).length,
             rejected: allocatorDecisions.filter(
-              (decision) => decision.decision === "rejected"
+              (decision) => decision.status === "rejected"
+            ).length,
+            notApplicable: allocatorDecisions.filter(
+              (decision) => decision.status === "not_applicable"
+            ).length,
+            unavailable: allocatorDecisions.filter(
+              (decision) => decision.status === "unavailable"
             ).length
           },
           risk: {
             available: riskDecisions.length > 0,
             approved: riskDecisions.filter(
-              (decision) => decision.decision === "approved"
+              (decision) => decision.status === "approved"
             ).length,
             rejected: riskDecisions.filter(
-              (decision) => decision.decision === "rejected"
-            ).length
+              (decision) => decision.status === "rejected"
+            ).length,
+            unavailable: riskDecisions.filter(
+              (decision) => decision.status === "unavailable"
+            ).length,
+            enforced: riskDecisions.some((decision) => decision.enforced === true)
           },
           orderAttempts: orderAttempts.length,
           orderFailures: orderAttempts.filter(
@@ -27583,8 +27695,16 @@ var init_runtimeScorecard = __esm({
         },
         execution: {
           available: actualSlippageBps != null || residualVsModelBps != null,
+          metricScope: arrivalToFillAdverseBps == null ? "signal_close_to_fill" : "signal_and_exchange_components",
+          samples: calibrationSamples.length,
+          fullTelemetryTrades,
+          arrivalQuoteCoverage,
           actualSignalToFillSlippageBps: actualSlippageBps,
-          residualVsCurrentModelBps: residualVsModelBps
+          residualVsCurrentModelBps: residualVsModelBps,
+          signalToArrivalAdverseBps,
+          arrivalToFillAdverseBps,
+          averageSignalCloseToSubmitMs,
+          averageSubmitToFillMs
         },
         prospective,
         rolling,
@@ -27638,10 +27758,10 @@ Window: ${new Date(scorecard.window.startTime).toISOString()} \u2014 ${new Date(
 
 - Evaluations: ${scorecard.funnel.evaluations}
 - Core candidates: ${scorecard.funnel.coreCandidates}
-- Gate approvals/rejects: ${scorecard.funnel.gate.approved}/${scorecard.funnel.gate.rejected}
+- Gate approvals/rejects: ${scorecard.funnel.gate.approved}/${scorecard.funnel.gate.rejected} (legacy fallback: ${scorecard.funnel.gate.legacyApprovedFallback})
 - AI / LLM disagreement: ${scorecard.gateComparison.disagreements}/${scorecard.gateComparison.compared}
-- Allocator approvals/rejects: ${scorecard.funnel.allocator.available ? `${scorecard.funnel.allocator.approved}/${scorecard.funnel.allocator.rejected}` : "unavailable"}
-- Risk approvals/rejects: ${scorecard.funnel.risk.available ? `${scorecard.funnel.risk.approved}/${scorecard.funnel.risk.rejected}` : "unavailable"}
+- Runtime admission approved/rejected/not-applicable: ${scorecard.funnel.allocator.available ? `${scorecard.funnel.allocator.approved}/${scorecard.funnel.allocator.rejected}/${scorecard.funnel.allocator.notApplicable}` : "unavailable"}
+- Risk assessment within/exceeds/unavailable: ${scorecard.funnel.risk.available ? `${scorecard.funnel.risk.approved}/${scorecard.funnel.risk.rejected}/${scorecard.funnel.risk.unavailable}` : "unavailable"} (enforced: ${scorecard.funnel.risk.enforced})
 - Order attempts/failures: ${scorecard.funnel.orderAttempts}/${scorecard.funnel.orderFailures}
 - Fills: ${scorecard.funnel.fills}
 - Closed trades: ${scorecard.funnel.closedTrades}
@@ -27650,8 +27770,14 @@ Window: ${new Date(scorecard.window.startTime).toISOString()} \u2014 ${new Date(
 
 - Parity: ${scorecard.parity.ratio == null ? "n/a" : `${round(scorecard.parity.ratio * 100, 2)}%`}
 - Runtime/replay mismatches: ${scorecard.parity.backtestOnly + scorecard.parity.runtimeOnly}
-- Actual signal-to-fill slippage: ${scorecard.execution.actualSignalToFillSlippageBps ?? "n/a"} bps
+- Execution metric scope: ${scorecard.execution.metricScope}
+- Telemetry samples/full/arrival coverage: ${scorecard.execution.samples}/${scorecard.execution.fullTelemetryTrades}/${scorecard.execution.arrivalQuoteCoverage == null ? "n/a" : `${round(scorecard.execution.arrivalQuoteCoverage * 100, 2)}%`}
+- Signal-close-to-fill adverse move: ${scorecard.execution.actualSignalToFillSlippageBps ?? "n/a"} bps
+- Signal-to-arrival adverse move: ${scorecard.execution.signalToArrivalAdverseBps ?? "n/a"} bps
+- Arrival-to-fill exchange slippage: ${scorecard.execution.arrivalToFillAdverseBps ?? "n/a"} bps
 - Residual vs current model: ${scorecard.execution.residualVsCurrentModelBps ?? "n/a"} bps
+- Average signal-close-to-submit: ${scorecard.execution.averageSignalCloseToSubmitMs ?? "n/a"} ms
+- Average submit-to-fill: ${scorecard.execution.averageSubmitToFillMs ?? "n/a"} ms
 
 ## Rolling performance
 
@@ -29179,6 +29305,11 @@ var init_runtimeScorecard2 = __esm({
       "Maximum acceptable execution residual in bps",
       3
     );
+    import_args30.default.option(
+      ["L", "maximumSignalCloseToSubmitMs"],
+      "Maximum acceptable average signal-close-to-submit latency in milliseconds",
+      3e4
+    );
     import_args30.default.option(
       ["T", "minimumClosedTrades"],
       "Minimum 7d closed trades for expectancy reactions",
@@ -29271,6 +29402,7 @@ var init_runtimeScorecard2 = __esm({
         thresholds: {
           minimumParityRatio: Number(flags29.minimumParityRatio),
           maximumSlippageResidualBps: Number(flags29.maximumSlippageResidualBps),
+          maximumSignalCloseToSubmitMs: Number(flags29.maximumSignalCloseToSubmitMs),
           minimumClosedTrades: Number(flags29.minimumClosedTrades),
           minimumExpectancy: Number(flags29.minimumExpectancy)
         },
@@ -32667,6 +32799,10 @@ var init_evaluations = __esm({
             lastTimestamp: Math.max(
               existing?.lastTimestamp ?? evaluation.timestamp,
               evaluation.timestamp
+            ),
+            evaluationRuns: appendRuntimeSignalEvaluationRun(
+              existing?.evaluationRuns,
+              evaluation
             )
           };
           runtimeLineageScopeCache.set(cacheKey, scope);
@@ -33398,6 +33534,8 @@ var init_tickerEvaluator = __esm({
           orderStatus: signal.orderStatus,
           orderSkipReason: signal.orderSkipReason,
           ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
+          ...signal.allocatorDecision ? { allocatorDecision: signal.allocatorDecision } : {},
+          ...signal.riskDecision ? { riskDecision: signal.riskDecision } : {},
           ...signal.ml ? { ml: signal.ml } : {}
         });
         import_logger9.logger.info("Signal found %s by strategy %s", symbol, strategyName);
@@ -35254,11 +35392,90 @@ var init_historicalSignalsReplayPreparation = __esm({
   }
 });
 
+// src/lib/replay/historicalSignalsReplaySkipEvidence.ts
+var import_data5, replayScopeKey, appendReplaySignalEvaluationRun, createHistoricalReplaySkipEvidence;
+var init_historicalSignalsReplaySkipEvidence = __esm({
+  "src/lib/replay/historicalSignalsReplaySkipEvidence.ts"() {
+    "use strict";
+    import_data5 = require("@tradejs/core/data");
+    replayScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
+    appendReplaySignalEvaluationRun = ({
+      runs = [],
+      reason,
+      timestamp,
+      interval: interval4
+    }) => {
+      const stepMs = (0, import_data5.intervalToMs)(interval4);
+      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
+        }
+      ];
+    };
+    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, advanceAbortedCycle, executeHistoricalReplay;
 var init_historicalSignalsReplayExecution = __esm({
   "src/lib/replay/historicalSignalsReplayExecution.ts"() {
     "use strict";
+    init_historicalSignalsReplaySkipEvidence();
     advanceCycleMarket = async (plan, connector, timestamp) => {
       const cycleSymbols = plan.cycleSymbolsByTimestamp.get(timestamp) ?? [];
       for (const symbolRuntime of cycleSymbols) {
@@ -35283,6 +35500,9 @@ var init_historicalSignalsReplayExecution = __esm({
     executeHistoricalReplay = async (context, adapters) => {
       const signals2 = [];
       let abortedCycles = 0;
+      const skipEvidence = createHistoricalReplaySkipEvidence(
+        context.plan.runtimeLineages
+      );
       try {
         for (const timestamp of context.plan.orderedTimestamps) {
           const cycleStartedAt = adapters.clock.now();
@@ -35325,6 +35545,14 @@ var init_historicalSignalsReplayExecution = __esm({
                 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);
@@ -35352,7 +35580,11 @@ var init_historicalSignalsReplayExecution = __esm({
           adapters.releaseReplayCache(keyPrefix);
         }
       }
-      return { signals: signals2, abortedCycles };
+      return {
+        signals: signals2,
+        abortedCycles,
+        replayLineageScopes: skipEvidence.values()
+      };
     };
   }
 });
@@ -35387,7 +35619,8 @@ var init_historicalSignalsReplayResults = __esm({
       positionLog: context.artifacts.positionLog,
       cycleCount: context.cycleCount,
       abortedCycles: context.abortedCycles,
-      runtimeLineages: context.runtimeLineages
+      runtimeLineages: context.runtimeLineages,
+      replayLineageScopes: context.replayLineageScopes
     });
   }
 });
@@ -35629,7 +35862,8 @@ var init_historicalSignalsReplay = __esm({
         signals: execution.signals,
         cycleCount: plan.orderedTimestamps.length,
         abortedCycles: execution.abortedCycles,
-        runtimeLineages: plan.runtimeLineages
+        runtimeLineages: plan.runtimeLineages,
+        replayLineageScopes: execution.replayLineageScopes
       });
     };
   }
@@ -36077,7 +36311,7 @@ var init_runtimeTradeSync = __esm({
 });
 
 // src/lib/runtimeParityDetails.ts
-var import_trade3, DEFAULT_REPLAY_PARITY_DETAILS_LIMIT, DEFAULT_REPLAY_PARITY_ARTIFACT_LIMIT, buildStrategyNameByOrderLinkKey, resolveReplayStrategyNameFromExchangeEntry, resolveReplayParityDetailsLimit, resolveReplayParityArtifactLimit, capReplayDetails, buildCostDetail, toBacktestParityDetail, toRuntimeParityDetail, toExchangeParityDetail, buildTimestampDelta, getComparisonTimestamp, getEntryStrategy, findNearestSignal, findNearestEvaluation, classifySignalDiagnostic, classifyEvaluationDiagnostic, summarizeMismatchDiagnostics, buildPnlDelta, buildPriceDeltaPct2, toFiniteNumberOrNull3, toAiDiagnostic, toSignalDiagnostic, toEvaluationDiagnostic, buildSlippageCost, buildMatchedReplayDetail, buildNearestCandidates, buildReplayMismatchDrilldown, buildReplayRuntimeComparisonDetails, buildReplayExchangeComparisonDetails;
+var import_trade3, DEFAULT_REPLAY_PARITY_DETAILS_LIMIT, DEFAULT_REPLAY_PARITY_ARTIFACT_LIMIT, buildStrategyNameByOrderLinkKey, resolveReplayStrategyNameFromExchangeEntry, resolveReplayParityDetailsLimit, resolveReplayParityArtifactLimit, capReplayDetails, buildCostDetail, toBacktestParityDetail, toRuntimeParityDetail, toExchangeParityDetail, buildTimestampDelta, getComparisonTimestamp, getEntryStrategy, findNearestSignal, findNearestEvaluation, findNearestRuntimeEvaluationOutcome, findNearestReplayEvaluationOutcome, hasRuntimeLineageCoverage, classifySignalDiagnostic, classifyEvaluationDiagnostic, summarizeMismatchDiagnostics, buildPnlDelta, buildPriceDeltaPct2, toFiniteNumberOrNull3, toAiDiagnostic, toSignalDiagnostic, toEvaluationDiagnostic, buildSlippageCost, buildMatchedReplayDetail, buildNearestCandidates, buildReplayMismatchDrilldown, buildReplayRuntimeComparisonDetails, buildReplayExchangeComparisonDetails;
 var init_runtimeParityDetails = __esm({
   "src/lib/runtimeParityDetails.ts"() {
     "use strict";
@@ -36253,6 +36487,90 @@ var init_runtimeParityDetails = __esm({
         timestampDiffMs: bestDiff
       } : null;
     };
+    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;
+    };
+    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;
+    };
+    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
+      );
+    };
     classifySignalDiagnostic = (signal) => {
       if (signal.orderStatus === "failed") {
         return {
@@ -36497,6 +36815,8 @@ var init_runtimeParityDetails = __esm({
       runtimeSignalEvaluations = [],
       replaySignals = [],
       replaySignalEvaluations = [],
+      replayLineageScopes = [],
+      runtimeLineageScopes = [],
       toleranceMs,
       backtestTimestampOffsetMs,
       limit
@@ -36522,7 +36842,16 @@ var init_runtimeParityDetails = __esm({
           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
         } : {
@@ -36546,7 +36875,8 @@ var init_runtimeParityDetails = __esm({
               timestampDiffMs: nearestReplayEvaluation.timestampDiffMs
             }),
             ...includeArtifacts ? { replayEvaluationArtifact: nearestReplayEvaluation.evaluation } : {}
-          } : {}
+          } : {},
+          ...nearestReplayEvaluationOutcome ? { replayEvaluationOutcome: nearestReplayEvaluationOutcome } : {}
         };
       });
       const backtestOnlyDiagnostics = backtestOnly.map((entry, index) => {
@@ -36564,9 +36894,26 @@ var init_runtimeParityDetails = __esm({
           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"
@@ -36590,7 +36937,8 @@ var init_runtimeParityDetails = __esm({
             ...includeArtifacts ? {
               runtimeEvaluationArtifact: nearestRuntimeEvaluation.evaluation
             } : {}
-          } : {}
+          } : {},
+          ...nearestRuntimeEvaluationOutcome ? { runtimeEvaluationOutcome: nearestRuntimeEvaluationOutcome } : {}
         };
       });
       for (const diagnostic of runtimeOnlyDiagnostics) {
@@ -36637,7 +36985,9 @@ var init_runtimeParityDetails = __esm({
       runtimeSignals,
       runtimeSignalEvaluations,
       replaySignals,
-      replaySignalEvaluations
+      replaySignalEvaluations,
+      replayLineageScopes,
+      runtimeLineageScopes
     }) => {
       const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
       const backtestDetails = backtestEntries.map(
@@ -36696,6 +37046,8 @@ var init_runtimeParityDetails = __esm({
           runtimeSignalEvaluations,
           replaySignals,
           replaySignalEvaluations,
+          replayLineageScopes,
+          runtimeLineageScopes,
           toleranceMs,
           backtestTimestampOffsetMs,
           limit
@@ -36716,7 +37068,9 @@ var init_runtimeParityDetails = __esm({
       runtimeSignals,
       runtimeSignalEvaluations,
       replaySignals,
-      replaySignalEvaluations
+      replaySignalEvaluations,
+      replayLineageScopes,
+      runtimeLineageScopes
     }) => {
       const toExchangeDetail = (entry) => toExchangeParityDetail({
         entry,
@@ -36803,6 +37157,8 @@ var init_runtimeParityDetails = __esm({
           runtimeSignalEvaluations,
           replaySignals,
           replaySignalEvaluations,
+          replayLineageScopes,
+          runtimeLineageScopes,
           toleranceMs,
           backtestTimestampOffsetMs,
           limit
@@ -36934,19 +37290,41 @@ var init_runtimeComparisonCalculations = __esm({
           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,
@@ -36958,6 +37336,7 @@ var init_runtimeComparisonCalculations = __esm({
           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("::");
@@ -37569,8 +37948,10 @@ var init_runtimeComparison = __esm({
       backtestEntries,
       replaySignals,
       replaySignalEvaluations,
+      replayLineageScopes,
       runtimeSignals,
       runtimeSignalEvaluations,
+      runtimeLineageScopes,
       lineage
     }) => {
       const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -37622,7 +38003,9 @@ var init_runtimeComparison = __esm({
           runtimeSignals,
           runtimeSignalEvaluations,
           replaySignals,
-          replaySignalEvaluations
+          replaySignalEvaluations,
+          runtimeLineageScopes,
+          replayLineageScopes
         });
         const emptyRowsByStrategy = new Map(
           buildExchangeComparisonRows({
@@ -37678,7 +38061,9 @@ var init_runtimeComparison = __esm({
         runtimeSignals,
         runtimeSignalEvaluations,
         replaySignals,
-        replaySignalEvaluations
+        replaySignalEvaluations,
+        runtimeLineageScopes,
+        replayLineageScopes
       });
       const rows = buildExchangeComparisonRows({
         liveStrategySummaries,
@@ -37716,6 +38101,7 @@ var init_runtimeComparison = __esm({
       backtestEntries,
       replaySignals,
       replayLineages,
+      replayLineageScopes,
       runtimeEvidencePath
     }) => {
       const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -37827,8 +38213,10 @@ var init_runtimeComparison = __esm({
           backtestEntries: comparableBacktestEntries,
           replaySignals,
           replaySignalEvaluations,
+          replayLineageScopes,
           runtimeSignals: comparable.runtimeSignals,
           runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
+          runtimeLineageScopes: comparable.runtimeLineageScopes,
           lineage: comparable.lineage
         });
       }
@@ -37852,7 +38240,9 @@ var init_runtimeComparison = __esm({
         runtimeSignals: comparable.runtimeSignals,
         runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
         replaySignals,
-        replaySignalEvaluations
+        replaySignalEvaluations,
+        runtimeLineageScopes: comparable.runtimeLineageScopes,
+        replayLineageScopes
       });
       const parityRows = summarizeTradeParityByStrategy({
         runtimeEntries: runtimeDedupe.entries,
@@ -37895,13 +38285,13 @@ var init_runtimeComparison = __esm({
 });
 
 // src/lib/replay/outputReport.ts
-var import_promises33, import_node_path30, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
+var import_promises33, import_node_path30, import_data6, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
 var init_outputReport = __esm({
   "src/lib/replay/outputReport.ts"() {
     "use strict";
     import_promises33 = __toESM(require("fs/promises"));
     import_node_path30 = __toESM(require("path"));
-    import_data4 = require("@tradejs/core/data");
+    import_data6 = require("@tradejs/core/data");
     init_support();
     formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
       timeZone: "Europe/Moscow",
@@ -38309,7 +38699,7 @@ var init_outputReport = __esm({
       ];
       await Promise.all([
         import_promises33.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-        import_promises33.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
+        import_promises33.default.writeFile(jsonPath, `${(0, import_data6.toJson)(report, true)}
 `, "utf8")
       ]);
       return {
@@ -38321,13 +38711,13 @@ var init_outputReport = __esm({
 });
 
 // src/scripts/replayRunner.ts
-var import_chalk53, import_constants19, import_data5, import_time14, import_redis21, prepareReplayBinanceMarketContext, finishReplay, replayBacktest;
+var import_chalk53, import_constants19, import_data7, import_time14, import_redis21, prepareReplayBinanceMarketContext, finishReplay, replayBacktest;
 var init_replayRunner = __esm({
   "src/scripts/replayRunner.ts"() {
     "use strict";
     import_chalk53 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
-    import_data5 = require("@tradejs/core/data");
+    import_data7 = require("@tradejs/core/data");
     import_time14 = require("@tradejs/core/time");
     import_redis21 = require("@tradejs/infra/redis");
     init_runFormatting();
@@ -38377,6 +38767,7 @@ var init_replayRunner = __esm({
         backtestEntries: replayStrategySnapshot.backtestEntries,
         replaySignals: replayResult.signals,
         replayLineages: replayResult.runtimeLineages,
+        replayLineageScopes: replayResult.replayLineageScopes,
         runtimeEvidencePath: replayRuntimeEvidencePath
       });
       const finishedAt = /* @__PURE__ */ new Date();
@@ -38543,7 +38934,7 @@ var init_replayRunner = __esm({
         deploymentId: deployment.id,
         assetClasses: deployment.assetClasses,
         deployment,
-        closedIntervalMs: (0, import_data5.intervalToMs)(replayInterval)
+        closedIntervalMs: (0, import_data7.intervalToMs)(replayInterval)
       });
       if (!preparedRun || isReplayUpdateOnlyRun) {
         return;