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

package/dist/scripts/aiTrain.js

@@ -827,7 +827,9 @@ var BASE_CONTEXT_FEATURE_SECTIONS = [
   "relative",
   "derivatives",
   "mtf",
-  "gateFeatures"
+  "gateFeatures",
+  "tickerProfile",
+  "portfolioContext"
 ];
 var asRecord = (value) => typeof value === "object" && value != null && !Array.isArray(value) ? value : null;
 var collectStrategyGateFeatures = (baseContext) => {
@@ -844,6 +846,7 @@ var pickBaseContextFeatureSections = (baseContext) => Object.fromEntries(
 );
 var buildAiTrainEvaluationFeatureSnapshot = ({
   additionalIndicators,
+  featureSnapshot,
   mode
 }) => {
   if (mode === "none") {
@@ -853,12 +856,14 @@ var buildAiTrainEvaluationFeatureSnapshot = ({
   const baseContext = asRecord(additional?.baseContext);
   if (!baseContext) {
     return {
-      baseContextAvailable: false
+      baseContextAvailable: false,
+      ...featureSnapshot ? { featureSnapshot } : {}
     };
   }
   const strategyGateFeatures = collectStrategyGateFeatures(baseContext);
   const snapshot = {
     baseContextAvailable: true,
+    ...featureSnapshot ? { featureSnapshot } : {},
     gateFeatures: baseContext.gateFeatures ?? null,
     ...strategyGateFeatures ? { strategyGateFeatures } : {}
   };
@@ -1059,6 +1064,8 @@ var RESEARCH_CONTEXT_ENV_KEYS = [
   "INTERVAL",
   "DERIVATIVES_CONTEXT_ENABLED",
   "DERIVATIVES_CONTEXT_TARGET_ENABLED",
+  "TICKER_PROFILES_PROVIDER",
+  "TICKER_PROFILES_UNIVERSE",
   "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
   "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
   "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
@@ -1093,13 +1100,15 @@ var writeAiTrainResearchSnapshot = async ({
 }) => {
   const resolvedPath = import_node_path2.default.resolve(outputPath);
   await import_promises2.default.mkdir(import_node_path2.default.dirname(resolvedPath), { recursive: true });
-  await import_promises2.default.writeFile(
-    resolvedPath,
-    `${JSON.stringify(result, null, 2)}
-`,
-    "utf8"
-  );
-  return resolvedPath;
+  const bytes = `${JSON.stringify(result)}
+`;
+  await import_promises2.default.writeFile(resolvedPath, bytes, "utf8");
+  return {
+    schema: "tradejs-research-report-receipt/v1",
+    path: resolvedPath,
+    bytes: Buffer.byteLength(bytes),
+    sha256: (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex")
+  };
 };
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
@@ -1416,6 +1425,7 @@ var extractSignalFromAiDatasetRow = (row) => {
   const { payload } = row;
   return {
     ...payload.signal,
+    aiFeatureReplay: { snapshot: payload.featureSnapshot ?? null },
     strategy: payload.signal.strategy,
     figures: payload.figures ?? {},
     indicators: payload.indicators ?? {},
@@ -1474,7 +1484,11 @@ import_args.default.option(
   "Save compact AI approval chart data for the strategies UI",
   false
 );
-import_args.default.option(["j", "json"], "Print structured JSON summary", false);
+import_args.default.option(
+  ["j", "json"],
+  "Print full JSON without --output; otherwise print its receipt",
+  false
+);
 import_args.default.option(
   ["O", "output"],
   "Write the structured JSON summary to a file and suppress table output",
@@ -1938,6 +1952,7 @@ var main = async () => {
       const isCorrect = aiApproved === profitableTrade;
       const features = buildAiTrainEvaluationFeatureSnapshot({
         additionalIndicators: payload.additionalIndicators,
+        featureSnapshot: payload.featureSnapshot,
         mode: dumpFeatureMode
       });
       evaluations.push({
@@ -2182,14 +2197,11 @@ var main = async () => {
       ttlMs: import_constants.TTL_1M
     });
   }
-  if (jsonOutputPath) {
-    await writeAiTrainResearchSnapshot({
-      outputPath: jsonOutputPath,
-      result
-    });
-  }
+  const reportReceipt = jsonOutputPath ? await writeAiTrainResearchSnapshot({ outputPath: jsonOutputPath, result }) : null;
   if (jsonOutput) {
-    if (printJsonOutput) {
+    if (reportReceipt) {
+      console.log(JSON.stringify(reportReceipt));
+    } else if (printJsonOutput) {
       console.log(JSON.stringify(result));
     }
     process.exit(failed === selectedRows ? 1 : 0);

package/dist/scripts/coreResearch.js

@@ -46,7 +46,7 @@ var import_node_path = __toESM(require("path"));
 
 // src/lib/coreResearch/types.ts
 var CORE_RESEARCH_SCHEMA = "tradejs-core-research/v1";
-var CORE_RESEARCH_RESULT_SCHEMA = "tradejs-core-research-result/v1";
+var CORE_RESEARCH_RESULT_SCHEMA = "tradejs-core-research-result/v2";
 var CORE_RESEARCH_LEDGER_SCHEMA = "tradejs-core-research-ledger/v1";
 
 // src/lib/coreResearch/io.ts
@@ -731,6 +731,14 @@ var writeCoreResearchTrades = async (params) => {
   }
   await closeOutput(output);
 };
+var summarizeCoreResearchComparison = (comparison) => {
+  const { matchedPairs, ...summary } = comparison;
+  return {
+    ...summary,
+    exitReasonChanges: matchedPairs.filter((pair) => pair.exitReasonChanged).length,
+    exitCodeChanges: matchedPairs.filter((pair) => pair.exitCodeChanged).length
+  };
+};
 
 // src/lib/coreResearch/metrics.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
@@ -1806,7 +1814,7 @@ var buildCurveSvg = (tradesByVariant, cohort, curve) => {
   )}</svg><div class="legend">${series.map((entry) => `<span><i style="background:${entry.color}"></i>${escapeHtml(entry.id)}</span>`).join("")}</div>`;
 };
 var comparisonCards = (comparisons) => comparisons.map(
-  (comparison) => `<article class="card"><h3>${escapeHtml(comparison.candidateId)} vs ${escapeHtml(comparison.controlId)}</h3><p class="verdict ${comparison.selection.passed ? "positive" : "negative"}">${comparison.selection.passed ? "PASS selection" : "REJECT selection"}</p><dl><dt>Matched</dt><dd>${comparison.matched}</dd><dt>Control only</dt><dd>${comparison.controlOnly}</dd><dt>Candidate only</dt><dd>${comparison.candidateOnly}</dd><dt>Identity retained</dt><dd>${format(comparison.matchedIdentityPctOfControl)}%</dd><dt>Exit reason changes</dt><dd>${comparison.matchedPairs.filter((pair) => pair.exitReasonChanged).length}</dd><dt>Exit code changes</dt><dd>${comparison.matchedPairs.filter((pair) => pair.exitCodeChanged).length}</dd><dt>Matched \u0394PnL</dt><dd>${format(comparison.cohorts.ALL.matchedPnlDelta)}</dd><dt>Removed control PnL</dt><dd>${format(comparison.cohorts.ALL.controlOnlyPnl)}</dd><dt>Added candidate PnL</dt><dd>${format(comparison.cohorts.ALL.candidateOnlyPnl)}</dd><dt>Aggregate \u0394PnL</dt><dd>${format(comparison.cohorts.ALL.delta.pnl)}</dd><dt>Aggregate \u0394DD</dt><dd>${format(comparison.cohorts.ALL.delta.realizedMaxDrawdown)}</dd><dt>Bootstrap P(\u0394&gt;0)</dt><dd>${format(comparison.bootstrap.probabilityPositive, 4)}</dd><dt>Holm p</dt><dd>${format(comparison.bootstrap.holmAdjustedPValue, 4)}</dd></dl><p>${comparison.selection.failedRules.length ? escapeHtml(comparison.selection.failedRules.map((rule) => `${rule.scope}.${rule.metric} ${rule.expected}`).join("; ")) : "All preregistered rules passed."}</p></article>`
+  (comparison) => `<article class="card"><h3>${escapeHtml(comparison.candidateId)} vs ${escapeHtml(comparison.controlId)}</h3><p class="verdict ${comparison.selection.passed ? "positive" : "negative"}">${comparison.selection.passed ? "PASS selection" : "REJECT selection"}</p><dl><dt>Matched</dt><dd>${comparison.matched}</dd><dt>Control only</dt><dd>${comparison.controlOnly}</dd><dt>Candidate only</dt><dd>${comparison.candidateOnly}</dd><dt>Identity retained</dt><dd>${format(comparison.matchedIdentityPctOfControl)}%</dd><dt>Exit reason changes</dt><dd>${comparison.exitReasonChanges}</dd><dt>Exit code changes</dt><dd>${comparison.exitCodeChanges}</dd><dt>Matched \u0394PnL</dt><dd>${format(comparison.cohorts.ALL.matchedPnlDelta)}</dd><dt>Removed control PnL</dt><dd>${format(comparison.cohorts.ALL.controlOnlyPnl)}</dd><dt>Added candidate PnL</dt><dd>${format(comparison.cohorts.ALL.candidateOnlyPnl)}</dd><dt>Aggregate \u0394PnL</dt><dd>${format(comparison.cohorts.ALL.delta.pnl)}</dd><dt>Aggregate \u0394DD</dt><dd>${format(comparison.cohorts.ALL.delta.realizedMaxDrawdown)}</dd><dt>Bootstrap P(\u0394&gt;0)</dt><dd>${format(comparison.bootstrap.probabilityPositive, 4)}</dd><dt>Holm p</dt><dd>${format(comparison.bootstrap.holmAdjustedPValue, 4)}</dd></dl><p>${comparison.selection.failedRules.length ? escapeHtml(comparison.selection.failedRules.map((rule) => `${rule.scope}.${rule.metric} ${rule.expected}`).join("; ")) : "All preregistered rules passed."}</p></article>`
 ).join("");
 var regimeRows = (variants) => {
   const keys = [
@@ -2491,7 +2499,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
       regimeCausality: "signal-time payload.additionalIndicators.baseContext only"
     },
     variants: analyses,
-    comparisons,
+    comparisons: comparisons.map(summarizeCoreResearchComparison),
     multipleTesting: {
       family: spec.hypothesis.family,
       hypotheses: Math.max(comparisons.length, familyHypotheses),
@@ -2524,7 +2532,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     artifactHashes: sourceHashes
   };
   await writeJsonAtomic(paths.resultPath, result);
-  await writeJsonAtomic(paths.comparisonPath, comparisons);
+  await writeJsonAtomic(paths.comparisonPath, result.comparisons);
   await writeCoreResearchMatches({ filePath: paths.matchesPath, comparisons });
   await writeCoreResearchTrades({
     filePath: paths.tradesPath,

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 = ({
@@ -5177,6 +5183,9 @@ var createPortfolioReplayConnector = (connector) => {
   let executionTimestamp = null;
   const positionsBySymbol = /* @__PURE__ */ new Map();
   const currentPriceBySymbol = /* @__PURE__ */ new Map();
+  const markedAtBySymbol = /* @__PURE__ */ new Map();
+  const entryFacts = /* @__PURE__ */ new Map();
+  let portfolioObserved = false;
   const orderLog = [];
   const positionLog = [];
   const orderLogByStrategy = /* @__PURE__ */ new Map();
@@ -5414,14 +5423,51 @@ var createPortfolioReplayConnector = (connector) => {
       const { strategyName: _strategyName, ...nextPosition } = position;
       return nextPosition;
     }),
+    getPortfolioObservation: async (asOf, reservations) => {
+      portfolioObserved = true;
+      const pendingIds = new Set(reservations.map((r) => r.id));
+      for (const id of entryFacts.keys())
+        if (!pendingIds.has(id)) entryFacts.delete(id);
+      return {
+        asOf,
+        positions: Array.from(positionsBySymbol.values()).map(
+          ({ position, stopLossPrice }) => ({
+            id: position.orderId ?? `${position.strategyName}:${position.symbol}:${position.timestamp}`,
+            strategy: position.strategyName === UNKNOWN_STRATEGY ? null : position.strategyName,
+            symbol: position.symbol,
+            direction: position.direction,
+            qty: position.qty,
+            entryPrice: position.price,
+            markPrice: currentPriceBySymbol.get(position.symbol) ?? null,
+            markedAt: markedAtBySymbol.get(position.symbol) ?? null,
+            stopLossPrice
+          })
+        ),
+        orders: reservations.map(
+          (r) => entryFacts.get(r.id) ?? {
+            id: r.id,
+            status: "pending",
+            filledQty: 0
+          }
+        )
+      };
+    },
     getOpenPositionPnl: async () => Array.from(positionsBySymbol.values()).map(
-      ({ position }) => getPositionPnlSnapshot({
-        position,
-        currentPrice: currentPriceBySymbol.get(position.symbol) ?? position.price
+      ({ position, stopLossPrice }) => ({
+        ...getPositionPnlSnapshot({
+          position,
+          currentPrice: currentPriceBySymbol.get(position.symbol) ?? position.price
+        }),
+        observedAt: markedAtBySymbol.get(position.symbol),
+        stopLossPrice
       })
     ),
     placeOrder: async (order) => {
-      const { beforeSubmit, ...submittedOrder } = order;
+      const {
+        beforeSubmit,
+        onRejected: _onRejected,
+        ...submittedOrder
+      } = order;
       if (positionsBySymbol.has(order.symbol)) {
         return false;
       }
@@ -5465,6 +5511,14 @@ var createPortfolioReplayConnector = (connector) => {
         stopLossPrice: null
       };
       positionsBySymbol.set(order.symbol, positionState);
+      markedAtBySymbol.set(order.symbol, executionTimestamp ?? order.timestamp);
+      if (portfolioObserved && order.orderId)
+        entryFacts.set(order.orderId, {
+          id: order.orderId,
+          status: "filled",
+          filledQty: order.qty,
+          positionId: order.orderId
+        });
       logOrder({
         positionState,
         data: {
@@ -5548,6 +5602,7 @@ var createPortfolioReplayConnector = (connector) => {
     getTickers: connector.getTickers,
     advanceMarket: async ({ symbol, candle }) => {
       executionTimestamp = candle.timestamp;
+      markedAtBySymbol.set(symbol, candle.timestamp);
       currentPriceBySymbol.set(symbol, candle.close);
       await checkSl({ symbol, candle });
       await checkTp({ symbol, candle });
@@ -5588,6 +5643,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 +5820,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 +5849,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 +5873,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 +5892,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 +5929,8 @@ var executeHistoricalReplay = async (context, adapters) => {
   return {
     signals,
     abortedCycles,
-    replayLineageScopes: skipEvidence.values()
+    replayLineageScopes: skipEvidence.values(),
+    replayDecisionTraces: decisionTrace.values()
   };
 };
 
@@ -5826,7 +5981,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 +6028,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 +6182,8 @@ var runHistoricalSignalsReplay = async ({
   references,
   showProgress = true,
   collectSkipEvidence = true,
-  collectSignals = true
+  collectSignals = true,
+  decisionTraceTargets
 }) => {
   const memory = createReplayMemoryProfile();
   memory?.("prepare:start");
@@ -6110,6 +6270,7 @@ var runHistoricalSignalsReplay = async ({
       connector: replayConnector,
       collectSkipEvidence,
       collectSignals,
+      decisionTraceTargets,
       hooks: projectHooks,
       hookContext
     },
@@ -6146,7 +6307,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 +6536,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 +7282,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 +7356,8 @@ var findNearestEvaluation = ({
   evaluations,
   toleranceMs,
   timestampOffsetMs,
-  entryTimestampOffsetMs = 0
+  entryTimestampOffsetMs = 0,
+  matchDirection = false
 }) => {
   const entryStrategy2 = getEntryStrategy(entry);
   if (!entryStrategy2) {
@@ -7202,7 +7367,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 +7713,7 @@ var buildReplayMismatchDrilldown = ({
   replaySignals = [],
   replaySignalEvaluations = [],
   replayLineageScopes = [],
+  replayDecisionTraces = [],
   runtimeLineageScopes = [],
   toleranceMs,
   backtestTimestampOffsetMs,
@@ -7556,48 +7722,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 +7907,7 @@ var buildReplayRuntimeComparisonDetails = ({
   replaySignals,
   replaySignalEvaluations,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeLineageScopes
 }) => {
   const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
@@ -7783,6 +7968,7 @@ var buildReplayRuntimeComparisonDetails = ({
       replaySignals,
       replaySignalEvaluations,
       replayLineageScopes,
+      replayDecisionTraces,
       runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
@@ -8808,6 +8994,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   replaySignals,
   replayLineages,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeEvidencePath
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -8959,7 +9146,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
     replaySignals,
     replaySignalEvaluations,
     runtimeLineageScopes: comparable.runtimeLineageScopes,
-    replayLineageScopes
+    replayLineageScopes,
+    replayDecisionTraces
   });
   const parityRows = summarizeTradeParityByStrategy({
     runtimeEntries: runtimeDedupe.entries,
@@ -9886,6 +10074,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 +10424,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;
   };