@tradejs/cli 3.1.29-beta.289 → 3.1.29-beta.290

package/dist/lib/runtimeFeedbackReplay.js

@@ -39,6 +39,7 @@ module.exports = __toCommonJS(runtimeFeedbackReplay_exports);
 var import_node_child_process = require("child_process");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
+var import_mcp = require("@tradejs/node/mcp");
 
 // src/lib/runtimeEvidenceDeployment.ts
 var runtimeEvidenceDeployment_exports = {};
@@ -186,44 +187,58 @@ var runLoggedCommand = async ({
   env,
   logHandle
 }) => {
-  await logHandle.write(`
-$ ${[executable, ...command].join(" ")}
-`);
-  await new Promise((resolve, reject) => {
-    let pendingLogWrite = Promise.resolve();
-    const appendLog = (chunk) => {
-      pendingLogWrite = pendingLogWrite.then(async () => {
-        await logHandle.write(chunk);
-      });
-    };
-    const child = (0, import_node_child_process.spawn)(executable, command, {
-      cwd,
-      env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.stdout.on("data", (chunk) => {
-      process.stdout.write(chunk);
-      appendLog(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      process.stderr.write(chunk);
-      appendLog(chunk);
-    });
+  await logHandle.writeFile(
+    "\n" + (0, import_mcp.formatMcpArtifactLogLine)(`$ ${[executable, ...command].join(" ")}`)
+  );
+  const child = (0, import_node_child_process.spawn)(executable, command, {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exit = new Promise((resolve, reject) => {
     child.once("error", reject);
     child.once("close", (code, signal) => {
-      void pendingLogWrite.then(() => {
-        if (code === 0) {
-          resolve();
-          return;
-        }
+      if (code === 0) resolve();
+      else {
         reject(
           new Error(
             `Runtime feedback command failed: exit=${String(code)} signal=${String(signal)}`
           )
         );
-      }, reject);
+      }
     });
   });
+  let pendingLogWrite = Promise.resolve();
+  const copyLog = async (input, output) => {
+    const writeLine = async (line) => {
+      const formatted = (0, import_mcp.formatMcpArtifactLogLine)(line);
+      pendingLogWrite = pendingLogWrite.then(
+        () => logHandle.writeFile(formatted)
+      );
+      await pendingLogWrite;
+      output.write(formatted);
+    };
+    let pendingLine = "";
+    try {
+      for await (const chunk of input.setEncoding("utf8")) {
+        const lines = (pendingLine + chunk).split("\n");
+        pendingLine = lines.pop() ?? "";
+        for (const line of lines) await writeLine(line);
+      }
+      if (pendingLine) await writeLine(pendingLine);
+    } catch (error) {
+      child.kill();
+      throw error;
+    }
+  };
+  const results = await Promise.allSettled([
+    copyLog(child.stdout, process.stdout),
+    copyLog(child.stderr, process.stderr),
+    exit
+  ]);
+  for (const result of results) {
+    if (result.status === "rejected") throw result.reason;
+  }
 };
 var runRuntimeFeedbackReplay = async ({
   runtimeEvidencePath,

package/dist/lib/runtimeParity.js

@@ -159,6 +159,7 @@ var extractRuntimeParityEntries = (trades) => trades.filter(
   direction: trade.direction,
   qty: toFiniteNumberOrNull(trade.qty),
   timestamp: trade.entryTimestamp,
+  ...Number.isFinite(trade.signalTimestamp) ? { signalTimestamp: trade.signalTimestamp } : {},
   price: toFiniteNumberOrNull(trade.entryPrice),
   orderId: trade.orderId,
   signalId: typeof trade.signalId === "string" ? trade.signalId : void 0,

package/dist/lib/runtimeParityDetails.js

@@ -45,6 +45,13 @@ var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
   return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
 };
 
+// src/lib/replay/historicalSignalsReplayDecisionTrace.ts
+var replayDecisionTraceKey = ({
+  strategy,
+  symbol,
+  signalTimestamp
+}) => JSON.stringify([strategy, symbol, signalTimestamp]);
+
 // src/lib/runtimeParityDetails.ts
 var DEFAULT_REPLAY_PARITY_DETAILS_LIMIT = 500;
 var DEFAULT_REPLAY_PARITY_ARTIFACT_LIMIT = 100;
@@ -120,6 +127,7 @@ var toRuntimeParityDetail = (entry) => ({
   direction: entry.direction,
   qty: entry.qty ?? null,
   timestamp: entry.timestamp,
+  ...entry.signalTimestamp != null ? { signalTimestamp: entry.signalTimestamp } : {},
   price: entry.price,
   exitType: entry.exitType ?? null,
   exitTimestamp: entry.exitTimestamp ?? null,
@@ -193,7 +201,8 @@ var findNearestEvaluation = ({
   evaluations,
   toleranceMs,
   timestampOffsetMs,
-  entryTimestampOffsetMs = 0
+  entryTimestampOffsetMs = 0,
+  matchDirection = false
 }) => {
   const entryStrategy = getEntryStrategy(entry);
   if (!entryStrategy) {
@@ -203,7 +212,7 @@ var findNearestEvaluation = ({
   let bestDiff = Number.POSITIVE_INFINITY;
   const entryTimestamp = entry.timestamp + entryTimestampOffsetMs;
   for (const evaluation of evaluations) {
-    if (evaluation.strategy !== entryStrategy || evaluation.symbol !== entry.symbol) {
+    if (evaluation.strategy !== entryStrategy || evaluation.symbol !== entry.symbol || matchDirection && evaluation.direction != null && evaluation.direction !== entry.direction) {
       continue;
     }
     const diff = Math.abs(
@@ -549,6 +558,7 @@ var buildReplayMismatchDrilldown = ({
   replaySignals = [],
   replaySignalEvaluations = [],
   replayLineageScopes = [],
+  replayDecisionTraces = [],
   runtimeLineageScopes = [],
   toleranceMs,
   backtestTimestampOffsetMs,
@@ -557,48 +567,66 @@ var buildReplayMismatchDrilldown = ({
   const nearestByEntry = new Map(
     nearestCandidates.map((candidate) => [candidate.entry, candidate])
   );
+  const traceByCandle = new Map(
+    replayDecisionTraces.map((trace) => [replayDecisionTraceKey(trace), trace])
+  );
   const artifactLimit = Math.min(limit, resolveReplayParityArtifactLimit());
   let runtimeOnlyArtifactsIncluded = 0;
   let backtestOnlyArtifactsIncluded = 0;
   const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
-    const entryOffsetMs = resolveTradeParityTimestampOffset(
-      getEntryStrategy(entry) ?? "",
-      backtestTimestampOffsetMs
-    );
+    const isRuntimeTrade = entry.source === "runtime";
+    const decisionEntry = isRuntimeTrade ? entry.signalTimestamp == null ? null : { ...entry, timestamp: entry.signalTimestamp } : entry;
+    const decisionClock = {
+      toleranceMs: isRuntimeTrade ? 0 : toleranceMs,
+      timestampOffsetMs: isRuntimeTrade ? 0 : resolveTradeParityTimestampOffset(
+        getEntryStrategy(entry) ?? "",
+        backtestTimestampOffsetMs
+      )
+    };
     const includeArtifacts = index < artifactLimit;
     const nearestCandidate = nearestByEntry.get(entry);
-    const nearestReplaySignal = findNearestSignal({
-      entry,
+    const nearestReplaySignal = decisionEntry && findNearestSignal({
+      entry: decisionEntry,
       signals: replaySignals,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      ...decisionClock
     });
-    const nearestReplayEvaluation = findNearestEvaluation({
-      entry,
+    const nearestReplayEvaluation = decisionEntry && findNearestEvaluation({
+      entry: decisionEntry,
       evaluations: replaySignalEvaluations,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      matchDirection: isRuntimeTrade,
+      ...decisionClock
     });
-    const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
-      entry,
+    const nearestReplayEvaluationOutcome = decisionEntry && findNearestReplayEvaluationOutcome({
+      entry: decisionEntry,
       lineageScopes: replayLineageScopes,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      ...decisionClock
     });
+    const strategy = getEntryStrategy(entry);
+    const replayDecisionTrace = isRuntimeTrade && strategy && decisionEntry ? traceByCandle.get(
+      replayDecisionTraceKey({
+        strategy,
+        symbol: entry.symbol,
+        signalTimestamp: decisionEntry.timestamp
+      })
+    ) : void 0;
+    const unavailableReason = !isRuntimeTrade ? "no_replay_signal_or_backtest_candidate" : !decisionEntry ? "replay_signal_timestamp_unavailable" : replayDecisionTrace?.decision.stage === "not_evaluated" ? replayDecisionTrace.decision.reason : "replay_evaluation_unavailable";
     const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
-      classification: "core_skipped",
+      classification: nearestReplayEvaluationOutcome.reason.startsWith(
+        "BACKTEST_ENTRY_DELAY_"
+      ) ? "entry_delayed" : "core_skipped",
       reason: nearestReplayEvaluationOutcome.reason
-    } : nearestCandidate?.nearest ? {
+    } : !isRuntimeTrade && nearestCandidate?.nearest ? {
       classification: "timing_or_price_drift",
       reason: nearestCandidate.reason
     } : {
       classification: "no_replay_candidate",
-      reason: "no_replay_signal_or_backtest_candidate"
+      reason: unavailableReason
     };
     return {
       entry,
       ...classification,
       ...nearestCandidate ? { nearestCandidate } : {},
+      ...replayDecisionTrace ? { replayDecisionTrace } : {},
       ...nearestReplaySignal ? {
         replaySignal: toSignalDiagnostic({
           signal: nearestReplaySignal.signal,
@@ -724,6 +752,7 @@ var buildReplayRuntimeComparisonDetails = ({
   replaySignals,
   replaySignalEvaluations,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeLineageScopes
 }) => {
   const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
@@ -784,6 +813,7 @@ var buildReplayRuntimeComparisonDetails = ({
       replaySignals,
       replaySignalEvaluations,
       replayLineageScopes,
+      replayDecisionTraces,
       runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,

package/dist/scripts/replay.js

@@ -4985,7 +4985,13 @@ var loadReplayRuntimeEvidenceMetadata = async (params) => {
     userName: artifact.userName,
     startTime: artifact.startTime,
     endTime: artifact.endTime,
-    deployment: artifact.deployment
+    deployment: artifact.deployment,
+    decisionTraceTargets: unwrapRows(
+      artifact.runtime.trades,
+      "trade"
+    ).flatMap(
+      ({ strategy, symbol, signalTimestamp }) => typeof signalTimestamp === "number" && Number.isFinite(signalTimestamp) && artifact.startTime != null && artifact.endTime != null && signalTimestamp >= artifact.startTime && signalTimestamp < artifact.endTime ? [{ strategy, symbol, signalTimestamp }] : []
+    )
   };
 };
 var buildRuntimeEvidenceLineageScopes = ({
@@ -5588,6 +5594,73 @@ var invokeAfterSignalsHooks = async (hooks, params) => {
   }
 };
 
+// src/lib/replay/historicalSignalsReplayDecisionTrace.ts
+var replayDecisionTraceKey = ({
+  strategy,
+  symbol,
+  signalTimestamp
+}) => JSON.stringify([strategy, symbol, signalTimestamp]);
+var describeOutcome = (result) => {
+  if (typeof result === "string") {
+    return {
+      stage: result.startsWith("BACKTEST_ENTRY_DELAY_") ? "entry_delay" : /(?:NO_PATTERN|POSITION_EXISTS)$/.test(result) ? "core" : "evaluation",
+      reason: result
+    };
+  }
+  if (!result) return { stage: "evaluation", reason: "NO_SIGNAL" };
+  const reason = result.orderSkipReason || result.orderFailureReason || result.orderStatus || "SIGNAL";
+  const patternContext = result.additionalIndicators?.tradingPatternsContext;
+  return {
+    stage: result.riskDecision?.status === "rejected" || /^ENTRY_(?:RR_BELOW|RISK_EXCEEDS)/.test(reason) ? "risk" : /^(?:AI_|ML_|HOOK_BEFORE_ENTRY_GATE|RESEARCH_ENTRY_POLICY)/.test(
+      reason
+    ) ? "gate" : result.orderStatus ? "execution" : "evaluation",
+    reason,
+    direction: result.direction,
+    orderStatus: result.orderStatus,
+    ...typeof patternContext?.selectedPattern === "string" ? { pattern: patternContext.selectedPattern } : {},
+    ...typeof patternContext?.sourceCode === "string" ? { patternCode: patternContext.sourceCode } : {}
+  };
+};
+var createReplayDecisionTrace = (targets = []) => {
+  const traces = /* @__PURE__ */ new Map();
+  const symbols = new Set(targets.map(({ symbol }) => symbol));
+  for (const target of targets) {
+    traces.set(replayDecisionTraceKey(target), {
+      ...target,
+      decision: {
+        stage: "not_evaluated",
+        reason: "REPLAY_CANDLE_NOT_EVALUATED"
+      }
+    });
+  }
+  const record = (strategy, symbol, candle, result, notEvaluatedReason) => {
+    if (!symbols.has(symbol)) return;
+    const { timestamp, open, high, low, close, volume } = candle;
+    const trace = traces.get(
+      replayDecisionTraceKey({ strategy, symbol, signalTimestamp: timestamp })
+    );
+    if (result && typeof result !== "string" && result.timestamp !== timestamp) {
+      const original = traces.get(
+        replayDecisionTraceKey({
+          strategy,
+          symbol,
+          signalTimestamp: result.timestamp
+        })
+      );
+      if (original)
+        original.followUp = {
+          ...describeOutcome(result),
+          candleTimestamp: timestamp
+        };
+      notEvaluatedReason = "REPLAY_PROCESSED_DELAYED_ENTRY";
+    }
+    if (!trace) return;
+    trace.candle = { timestamp, open, high, low, close, volume };
+    trace.decision = notEvaluatedReason ? { stage: "not_evaluated", reason: notEvaluatedReason } : describeOutcome(result);
+  };
+  return { record, values: () => [...traces.values()] };
+};
+
 // src/lib/replay/historicalSignalsReplaySkipEvidence.ts
 var import_data2 = require("@tradejs/core/data");
 var replayScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
@@ -5698,6 +5771,7 @@ var executeHistoricalReplay = async (context, adapters) => {
     context.plan.runtimeLineages,
     context.collectSkipEvidence
   );
+  const decisionTrace = createReplayDecisionTrace(context.decisionTraceTargets);
   const reportProgress = (timestamp) => {
     if (adapters.progress.enabled === false) return;
     adapters.progress.tick({
@@ -5726,6 +5800,20 @@ var executeHistoricalReplay = async (context, adapters) => {
           status: "completed",
           durationMs: adapters.clock.now() - cycleStartedAt
         });
+        if (context.decisionTraceTargets?.length) {
+          for (const symbolRuntime of cycleSymbols) {
+            const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
+            for (const strategy of symbolRuntime.strategies) {
+              decisionTrace.record(
+                strategy.strategyName,
+                symbolRuntime.symbol,
+                candle,
+                void 0,
+                "REPLAY_CYCLE_ABORTED"
+              );
+            }
+          }
+        }
         advanceAbortedCycle(cycleSymbols, timestamp);
         reportProgress(timestamp);
         continue;
@@ -5736,6 +5824,17 @@ var executeHistoricalReplay = async (context, adapters) => {
         const btcCandle = symbolRuntime.btcReplayData[symbolRuntime.currentIndex];
         const ethCandle = symbolRuntime.ethReplayData[symbolRuntime.currentIndex];
         if (!candle || !btcCandle || candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) !== timestamp || btcCandle.timestamp !== candle.timestamp) {
+          if (candle && context.decisionTraceTargets?.length) {
+            for (const strategy of symbolRuntime.strategies) {
+              decisionTrace.record(
+                strategy.strategyName,
+                symbolRuntime.symbol,
+                candle,
+                void 0,
+                "REPLAY_CANDLE_OR_REFERENCE_NOT_ALIGNED"
+              );
+            }
+          }
           continue;
         }
         for (const strategyRuntime of symbolRuntime.strategies) {
@@ -5744,6 +5843,12 @@ var executeHistoricalReplay = async (context, adapters) => {
             btcCandle,
             ethCandle?.timestamp === candle.timestamp ? ethCandle : void 0
           );
+          decisionTrace.record(
+            strategyRuntime.strategyName,
+            symbolRuntime.symbol,
+            candle,
+            result
+          );
           skipEvidence.record({
             strategyName: strategyRuntime.strategyName,
             symbol: symbolRuntime.symbol,
@@ -5775,7 +5880,8 @@ var executeHistoricalReplay = async (context, adapters) => {
   return {
     signals,
     abortedCycles,
-    replayLineageScopes: skipEvidence.values()
+    replayLineageScopes: skipEvidence.values(),
+    replayDecisionTraces: decisionTrace.values()
   };
 };
 
@@ -5826,7 +5932,8 @@ var collectHistoricalReplayResult = (context) => ({
   cycleCount: context.cycleCount,
   abortedCycles: context.abortedCycles,
   runtimeLineages: context.runtimeLineages,
-  replayLineageScopes: context.replayLineageScopes
+  replayLineageScopes: context.replayLineageScopes,
+  ...context.replayDecisionTraces?.length ? { replayDecisionTraces: context.replayDecisionTraces } : {}
 });
 var compactHistoricalReplayResultForPortfolio = (result) => ({
   ...result,
@@ -5872,7 +5979,10 @@ var mergeHistoricalReplayResults = (parts) => {
     cycleCount: parts.reduce((sum, part) => sum + part.cycleCount, 0),
     abortedCycles: parts.reduce((sum, part) => sum + part.abortedCycles, 0),
     runtimeLineages: parts.flatMap((part) => part.runtimeLineages),
-    replayLineageScopes: parts.flatMap((part) => part.replayLineageScopes)
+    replayLineageScopes: parts.flatMap((part) => part.replayLineageScopes),
+    replayDecisionTraces: parts.flatMap(
+      (part) => part.replayDecisionTraces ?? []
+    )
   };
 };
 
@@ -6023,7 +6133,8 @@ var runHistoricalSignalsReplay = async ({
   references,
   showProgress = true,
   collectSkipEvidence = true,
-  collectSignals = true
+  collectSignals = true,
+  decisionTraceTargets
 }) => {
   const memory = createReplayMemoryProfile();
   memory?.("prepare:start");
@@ -6110,6 +6221,7 @@ var runHistoricalSignalsReplay = async ({
       connector: replayConnector,
       collectSkipEvidence,
       collectSignals,
+      decisionTraceTargets,
       hooks: projectHooks,
       hookContext
     },
@@ -6146,7 +6258,8 @@ var runHistoricalSignalsReplay = async ({
     cycleCount: plan.orderedTimestamps.length,
     abortedCycles: execution.abortedCycles,
     runtimeLineages: plan.runtimeLineages,
-    replayLineageScopes: execution.replayLineageScopes
+    replayLineageScopes: execution.replayLineageScopes,
+    replayDecisionTraces: execution.replayDecisionTraces
   });
   memory?.("result:collected");
   return result;
@@ -6374,6 +6487,7 @@ var extractRuntimeParityEntries = (trades) => trades.filter(
   direction: trade.direction,
   qty: toFiniteNumberOrNull2(trade.qty),
   timestamp: trade.entryTimestamp,
+  ...Number.isFinite(trade.signalTimestamp) ? { signalTimestamp: trade.signalTimestamp } : {},
   price: toFiniteNumberOrNull2(trade.entryPrice),
   orderId: trade.orderId,
   signalId: typeof trade.signalId === "string" ? trade.signalId : void 0,
@@ -7119,6 +7233,7 @@ var toRuntimeParityDetail = (entry) => ({
   direction: entry.direction,
   qty: entry.qty ?? null,
   timestamp: entry.timestamp,
+  ...entry.signalTimestamp != null ? { signalTimestamp: entry.signalTimestamp } : {},
   price: entry.price,
   exitType: entry.exitType ?? null,
   exitTimestamp: entry.exitTimestamp ?? null,
@@ -7192,7 +7307,8 @@ var findNearestEvaluation = ({
   evaluations,
   toleranceMs,
   timestampOffsetMs,
-  entryTimestampOffsetMs = 0
+  entryTimestampOffsetMs = 0,
+  matchDirection = false
 }) => {
   const entryStrategy2 = getEntryStrategy(entry);
   if (!entryStrategy2) {
@@ -7202,7 +7318,7 @@ var findNearestEvaluation = ({
   let bestDiff = Number.POSITIVE_INFINITY;
   const entryTimestamp = entry.timestamp + entryTimestampOffsetMs;
   for (const evaluation of evaluations) {
-    if (evaluation.strategy !== entryStrategy2 || evaluation.symbol !== entry.symbol) {
+    if (evaluation.strategy !== entryStrategy2 || evaluation.symbol !== entry.symbol || matchDirection && evaluation.direction != null && evaluation.direction !== entry.direction) {
       continue;
     }
     const diff = Math.abs(
@@ -7548,6 +7664,7 @@ var buildReplayMismatchDrilldown = ({
   replaySignals = [],
   replaySignalEvaluations = [],
   replayLineageScopes = [],
+  replayDecisionTraces = [],
   runtimeLineageScopes = [],
   toleranceMs,
   backtestTimestampOffsetMs,
@@ -7556,48 +7673,66 @@ var buildReplayMismatchDrilldown = ({
   const nearestByEntry = new Map(
     nearestCandidates.map((candidate) => [candidate.entry, candidate])
   );
+  const traceByCandle = new Map(
+    replayDecisionTraces.map((trace) => [replayDecisionTraceKey(trace), trace])
+  );
   const artifactLimit = Math.min(limit, resolveReplayParityArtifactLimit());
   let runtimeOnlyArtifactsIncluded = 0;
   let backtestOnlyArtifactsIncluded = 0;
   const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
-    const entryOffsetMs = resolveTradeParityTimestampOffset(
-      getEntryStrategy(entry) ?? "",
-      backtestTimestampOffsetMs
-    );
+    const isRuntimeTrade = entry.source === "runtime";
+    const decisionEntry = isRuntimeTrade ? entry.signalTimestamp == null ? null : { ...entry, timestamp: entry.signalTimestamp } : entry;
+    const decisionClock = {
+      toleranceMs: isRuntimeTrade ? 0 : toleranceMs,
+      timestampOffsetMs: isRuntimeTrade ? 0 : resolveTradeParityTimestampOffset(
+        getEntryStrategy(entry) ?? "",
+        backtestTimestampOffsetMs
+      )
+    };
     const includeArtifacts = index < artifactLimit;
     const nearestCandidate = nearestByEntry.get(entry);
-    const nearestReplaySignal = findNearestSignal({
-      entry,
+    const nearestReplaySignal = decisionEntry && findNearestSignal({
+      entry: decisionEntry,
       signals: replaySignals,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      ...decisionClock
     });
-    const nearestReplayEvaluation = findNearestEvaluation({
-      entry,
+    const nearestReplayEvaluation = decisionEntry && findNearestEvaluation({
+      entry: decisionEntry,
       evaluations: replaySignalEvaluations,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      matchDirection: isRuntimeTrade,
+      ...decisionClock
     });
-    const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
-      entry,
+    const nearestReplayEvaluationOutcome = decisionEntry && findNearestReplayEvaluationOutcome({
+      entry: decisionEntry,
       lineageScopes: replayLineageScopes,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      ...decisionClock
     });
+    const strategy = getEntryStrategy(entry);
+    const replayDecisionTrace = isRuntimeTrade && strategy && decisionEntry ? traceByCandle.get(
+      replayDecisionTraceKey({
+        strategy,
+        symbol: entry.symbol,
+        signalTimestamp: decisionEntry.timestamp
+      })
+    ) : void 0;
+    const unavailableReason = !isRuntimeTrade ? "no_replay_signal_or_backtest_candidate" : !decisionEntry ? "replay_signal_timestamp_unavailable" : replayDecisionTrace?.decision.stage === "not_evaluated" ? replayDecisionTrace.decision.reason : "replay_evaluation_unavailable";
     const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
-      classification: "core_skipped",
+      classification: nearestReplayEvaluationOutcome.reason.startsWith(
+        "BACKTEST_ENTRY_DELAY_"
+      ) ? "entry_delayed" : "core_skipped",
       reason: nearestReplayEvaluationOutcome.reason
-    } : nearestCandidate?.nearest ? {
+    } : !isRuntimeTrade && nearestCandidate?.nearest ? {
       classification: "timing_or_price_drift",
       reason: nearestCandidate.reason
     } : {
       classification: "no_replay_candidate",
-      reason: "no_replay_signal_or_backtest_candidate"
+      reason: unavailableReason
     };
     return {
       entry,
       ...classification,
       ...nearestCandidate ? { nearestCandidate } : {},
+      ...replayDecisionTrace ? { replayDecisionTrace } : {},
       ...nearestReplaySignal ? {
         replaySignal: toSignalDiagnostic({
           signal: nearestReplaySignal.signal,
@@ -7723,6 +7858,7 @@ var buildReplayRuntimeComparisonDetails = ({
   replaySignals,
   replaySignalEvaluations,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeLineageScopes
 }) => {
   const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
@@ -7783,6 +7919,7 @@ var buildReplayRuntimeComparisonDetails = ({
       replaySignals,
       replaySignalEvaluations,
       replayLineageScopes,
+      replayDecisionTraces,
       runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
@@ -8808,6 +8945,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   replaySignals,
   replayLineages,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeEvidencePath
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -8959,7 +9097,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
     replaySignals,
     replaySignalEvaluations,
     runtimeLineageScopes: comparable.runtimeLineageScopes,
-    replayLineageScopes
+    replayLineageScopes,
+    replayDecisionTraces
   });
   const parityRows = summarizeTradeParityByStrategy({
     runtimeEntries: runtimeDedupe.entries,
@@ -9886,6 +10025,7 @@ var finishReplay = async ({
     replaySignals: replayResult.signals,
     replayLineages: replayResult.runtimeLineages,
     replayLineageScopes: replayResult.replayLineageScopes,
+    replayDecisionTraces: replayResult.replayDecisionTraces,
     runtimeEvidencePath: replayRuntimeEvidencePath
   });
   const finishedAt = /* @__PURE__ */ new Date();
@@ -10235,7 +10375,8 @@ var replayBacktest = async () => {
       references: historicalReplayReferences,
       showProgress: !replayFlags.portfolioReport,
       collectSkipEvidence: !replayFlags.portfolioReport,
-      collectSignals: !replayFlags.portfolioReport
+      collectSignals: !replayFlags.portfolioReport,
+      decisionTraceTargets: replayFlags.portfolioReport ? void 0 : evidenceMetadata?.decisionTraceTargets
     });
     return replayFlags.portfolioReport ? compactHistoricalReplayResultForPortfolio(result) : result;
   };