@tradejs/cli 3.1.29-beta.281 → 3.1.29-beta.283

package/dist/lib/runtimeFeedbackProcess.js

@@ -0,0 +1,1700 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeFeedbackProcess.ts
+var runtimeFeedbackProcess_exports = {};
+__export(runtimeFeedbackProcess_exports, {
+  processRuntimeFeedbackPair: () => processRuntimeFeedbackPair
+});
+module.exports = __toCommonJS(runtimeFeedbackProcess_exports);
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_crypto2 = require("crypto");
+var import_diagnostics = require("@tradejs/node/diagnostics");
+
+// src/lib/executionCalibration.ts
+var import_constants = require("@tradejs/core/constants");
+var import_data = require("@tradejs/core/data");
+var import_trade = require("@tradejs/core/trade");
+var roundMetric = (value, decimals = 6) => typeof value === "number" && Number.isFinite(value) ? Number(value.toFixed(decimals)) : null;
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var finiteString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var finiteDirection = (value) => value === "LONG" || value === "SHORT" ? value : null;
+var metricValues = (samples, key) => samples.map((sample) => sample[key]).filter(
+  (value) => typeof value === "number" && Number.isFinite(value)
+);
+var quantile = (values, probability) => {
+  if (!values.length) {
+    return null;
+  }
+  const sorted = [...values].sort((left, right) => left - right);
+  const index = (sorted.length - 1) * probability;
+  const lowerIndex = Math.floor(index);
+  const upperIndex = Math.ceil(index);
+  const lower = sorted[lowerIndex];
+  const upper = sorted[upperIndex];
+  if (lower == null || upper == null) {
+    return null;
+  }
+  if (lowerIndex === upperIndex) {
+    return lower;
+  }
+  return lower + (upper - lower) * (index - lowerIndex);
+};
+var summarizeNumbers = (values) => {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (!finite.length) {
+    return {
+      count: 0,
+      min: null,
+      max: null,
+      avg: null,
+      p50: null,
+      p75: null,
+      p90: null,
+      p95: null
+    };
+  }
+  const total = finite.reduce((sum2, value) => sum2 + value, 0);
+  return {
+    count: finite.length,
+    min: roundMetric(Math.min(...finite)),
+    max: roundMetric(Math.max(...finite)),
+    avg: roundMetric(total / finite.length),
+    p50: roundMetric(quantile(finite, 0.5)),
+    p75: roundMetric(quantile(finite, 0.75)),
+    p90: roundMetric(quantile(finite, 0.9)),
+    p95: roundMetric(quantile(finite, 0.95))
+  };
+};
+var getIntervalMs = (interval) => {
+  if (!interval) {
+    return null;
+  }
+  try {
+    return (0, import_data.intervalToMs)(interval);
+  } catch {
+    return null;
+  }
+};
+var getSignalKey = ({
+  strategy,
+  symbol,
+  timestamp
+}) => strategy && symbol && timestamp != null ? `${strategy}:${symbol}:${timestamp}` : null;
+var addSignalToMap = (signalsById, signalsByShape, signal) => {
+  if (!signal) {
+    return;
+  }
+  const signalId = finiteString(signal.signalId);
+  if (signalId) {
+    signalsById.set(signalId, signal);
+  }
+  const shapeKey = getSignalKey({
+    strategy: finiteString(signal.strategy),
+    symbol: finiteString(signal.symbol),
+    timestamp: finiteNumber(signal.timestamp)
+  });
+  if (shapeKey) {
+    signalsByShape.set(shapeKey, signal);
+  }
+};
+var getRuntimePayload = ({
+  runtimeArtifact,
+  replayEvidenceArtifact
+}) => {
+  const explicitRuntime = asRecord(runtimeArtifact);
+  if (explicitRuntime) {
+    return asRecord(explicitRuntime.runtime) ?? explicitRuntime;
+  }
+  const replayEvidence = asRecord(replayEvidenceArtifact);
+  return asRecord(replayEvidence?.runtime);
+};
+var extractRuntimeTradeRows = (runtimePayload2) => {
+  if (!runtimePayload2) {
+    return [];
+  }
+  const signalsById = /* @__PURE__ */ new Map();
+  const signalsByShape = /* @__PURE__ */ new Map();
+  for (const signalRow of asArray(runtimePayload2.signals)) {
+    const record = asRecord(signalRow);
+    addSignalToMap(
+      signalsById,
+      signalsByShape,
+      asRecord(record?.signal) ?? record
+    );
+  }
+  return asArray(runtimePayload2.trades).map((row) => {
+    const record = asRecord(row);
+    if (!record) {
+      return null;
+    }
+    const redisValues = asRecord(record.redisValues);
+    const trade = asRecord(record.trade) ?? asRecord(redisValues?.trade) ?? record;
+    const signalId = finiteString(trade.signalId);
+    const shapeKey = getSignalKey({
+      strategy: finiteString(trade.strategy),
+      symbol: finiteString(trade.symbol),
+      timestamp: finiteNumber(trade.signalTimestamp ?? trade.entryTimestamp)
+    });
+    const signal = asRecord(redisValues?.signal) ?? (signalId ? signalsById.get(signalId) ?? null : null) ?? (shapeKey ? signalsByShape.get(shapeKey) ?? null : null);
+    return {
+      trade,
+      signal,
+      runtimeLineage: asRecord(trade.runtimeLineage) ?? null
+    };
+  }).filter((row) => row != null);
+};
+var normalizeReplayMatch = (value) => {
+  const item = asRecord(value);
+  if (!item) {
+    return null;
+  }
+  const runtime = asRecord(item.runtime);
+  const backtest = asRecord(item.backtest);
+  return {
+    orderId: finiteString(
+      item.orderId ?? runtime?.orderId ?? backtest?.orderId
+    ),
+    orderLinkId: finiteString(item.orderLinkId ?? runtime?.orderLinkId),
+    signalId: finiteString(item.signalId ?? backtest?.signalId),
+    strategy: finiteString(
+      item.strategy ?? backtest?.strategy ?? runtime?.inferredStrategy
+    ),
+    symbol: finiteString(item.symbol ?? backtest?.symbol ?? runtime?.symbol),
+    direction: finiteDirection(
+      item.direction ?? backtest?.direction ?? runtime?.direction
+    ),
+    backtestPrice: finiteNumber(item.backtestPrice ?? backtest?.price),
+    runtimePrice: finiteNumber(item.runtimePrice ?? runtime?.price)
+  };
+};
+var extractReplayMatches = (replayEvidenceArtifact) => {
+  const artifact = asRecord(replayEvidenceArtifact);
+  if (!artifact) {
+    return [];
+  }
+  const replay = asRecord(artifact.replay) ?? artifact;
+  const runtimeComparison = asRecord(replay.runtimeComparison);
+  const details = asRecord(runtimeComparison?.details);
+  const matched = asArray(runtimeComparison?.matched).length ? asArray(runtimeComparison?.matched) : asArray(details?.matched);
+  return matched.map(normalizeReplayMatch).filter((match) => match != null);
+};
+var buildReplayMatchMaps = (matches) => {
+  const maps = {
+    byOrderId: /* @__PURE__ */ new Map(),
+    bySignalId: /* @__PURE__ */ new Map()
+  };
+  for (const match of matches) {
+    for (const orderId of [match.orderLinkId, match.orderId]) {
+      if (orderId) {
+        maps.byOrderId.set(orderId, match);
+      }
+    }
+    if (match.signalId) {
+      maps.bySignalId.set(match.signalId, match);
+    }
+  }
+  return maps;
+};
+var getSignalCandles = (signal, interval) => {
+  const indicators = asRecord(signal?.indicators);
+  if (!indicators) {
+    return null;
+  }
+  const intervalKey = (() => {
+    switch (interval) {
+      case "15":
+        return "candles15m";
+      case "60":
+        return "candles1h";
+      case "240":
+        return "candles4h";
+      case "D":
+        return "candles1d";
+      default:
+        return null;
+    }
+  })();
+  const keys = [
+    intervalKey,
+    "candles15m",
+    "candles1h",
+    "candles4h",
+    "candles1d",
+    "candles"
+  ].filter((key) => Boolean(key));
+  for (const key of keys) {
+    const value = indicators[key];
+    if (Array.isArray(value) && value.length > 1) {
+      return value;
+    }
+  }
+  const candle = indicators.candle;
+  const prevCandle = indicators.prevCandle;
+  return prevCandle && candle ? [prevCandle, candle] : null;
+};
+var adverseEntryBps = ({
+  direction,
+  expectedPrice,
+  actualPrice
+}) => {
+  if (!direction || expectedPrice == null || actualPrice == null || expectedPrice <= 0 || actualPrice <= 0) {
+    return null;
+  }
+  const value = direction === "LONG" ? (actualPrice / expectedPrice - 1) * 1e4 : (expectedPrice / actualPrice - 1) * 1e4;
+  return roundMetric(value);
+};
+var feeBps = ({
+  fee,
+  fillAvgPrice,
+  qty
+}) => {
+  const notional = fillAvgPrice != null && qty != null && fillAvgPrice > 0 && qty > 0 ? fillAvgPrice * qty : null;
+  return fee != null && notional != null && notional > 0 ? roundMetric(fee / notional * 1e4) : null;
+};
+var latencyDelta = (end, start) => end != null && start != null ? roundMetric(end - start, 3) : null;
+var resolveTelemetryQuality = ({
+  signalClosePrice,
+  arrivalMid,
+  orderSubmitTime,
+  orderAckTime,
+  fillAvgPrice,
+  fillTime
+}) => {
+  if (signalClosePrice != null && arrivalMid != null && orderSubmitTime != null && orderAckTime != null && fillAvgPrice != null && fillTime != null) {
+    return "full";
+  }
+  if (fillAvgPrice != null && (arrivalMid != null || orderSubmitTime != null)) {
+    return "partial";
+  }
+  if (fillAvgPrice != null) {
+    return "price_only";
+  }
+  return "none";
+};
+var finiteTelemetryQuality = (value) => {
+  const raw = finiteString(value);
+  return raw === "full" || raw === "partial" || raw === "price_only" || raw === "none" ? raw : null;
+};
+var countBy = (samples, keyGetter) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const sample of samples) {
+    const key = keyGetter(sample) ?? "unknown";
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return Object.fromEntries(
+    [...counts.entries()].sort(([left], [right]) => left.localeCompare(right))
+  );
+};
+var toLatencyBucket = (sample) => {
+  const latencyMs = sample.signalCloseToSubmitMs ?? sample.signalToSubmitMs;
+  if (latencyMs == null || !Number.isFinite(latencyMs)) return "unknown";
+  if (latencyMs <= 1e3) return "0-1s";
+  if (latencyMs <= 5e3) return "1-5s";
+  if (latencyMs <= 3e4) return "5-30s";
+  if (latencyMs <= 12e4) return "30-120s";
+  return "120s+";
+};
+var toSpreadBucket = (sample) => {
+  const spreadBps = sample.spreadBps;
+  if (spreadBps == null || !Number.isFinite(spreadBps)) return "unknown";
+  if (spreadBps <= 5) return "0-5bps";
+  if (spreadBps <= 20) return "5-20bps";
+  if (spreadBps <= 50) return "20-50bps";
+  return "50bps+";
+};
+var buildSample = ({
+  row,
+  match
+}) => {
+  const { trade, signal } = row;
+  const strategy = finiteString(trade.strategy ?? signal?.strategy);
+  const symbol = finiteString(trade.symbol ?? signal?.symbol);
+  const interval = finiteString(trade.interval ?? signal?.interval);
+  const direction = finiteDirection(trade.direction ?? signal?.direction);
+  const orderId = finiteString(trade.orderId);
+  const signalId = finiteString(trade.signalId ?? signal?.signalId);
+  const qty = finiteNumber(trade.qty);
+  const signalTimestamp = finiteNumber(
+    trade.signalTimestamp ?? signal?.timestamp
+  );
+  const intervalMs = getIntervalMs(interval);
+  const signalCloseTimestamp = signalTimestamp != null && intervalMs != null ? signalTimestamp + intervalMs : signalTimestamp;
+  const signalClosePrice = finiteNumber(trade.signalClosePrice);
+  const arrivalSnapshotTime = finiteNumber(trade.arrivalSnapshotTime);
+  const arrivalSource = finiteString(trade.arrivalSource);
+  const arrivalMid = finiteNumber(trade.arrivalMid);
+  const bid = finiteNumber(trade.bid);
+  const ask = finiteNumber(trade.ask);
+  const spreadBps = finiteNumber(trade.spreadBps);
+  const orderSubmitTime = finiteNumber(trade.orderSubmitTime);
+  const orderAckTime = finiteNumber(trade.orderAckTime);
+  const fillAvgPrice = finiteNumber(trade.fillAvgPrice);
+  const fillSource = finiteString(trade.fillSource);
+  const fillTime = finiteNumber(trade.fillTime);
+  const telemetryQuality = finiteTelemetryQuality(trade.telemetryQuality) ?? resolveTelemetryQuality({
+    signalClosePrice,
+    arrivalMid,
+    orderSubmitTime,
+    orderAckTime,
+    fillAvgPrice,
+    fillTime
+  });
+  const fee = finiteNumber(trade.fee ?? trade.openFee);
+  const arrivalSnapshotAgeMs = latencyDelta(
+    orderSubmitTime,
+    arrivalSnapshotTime
+  );
+  const signalToSubmitMs = latencyDelta(orderSubmitTime, signalTimestamp);
+  const signalCloseToSubmitMs = latencyDelta(
+    orderSubmitTime,
+    signalCloseTimestamp
+  );
+  const submitToAckMs = latencyDelta(orderAckTime, orderSubmitTime);
+  const submitToFillMs = latencyDelta(fillTime, orderSubmitTime);
+  const orderAckToFillMs = latencyDelta(fillTime, orderAckTime);
+  const signalToFillMs = latencyDelta(fillTime, signalTimestamp);
+  const observedDelayMs = signalCloseToSubmitMs != null && signalCloseToSubmitMs >= 0 ? signalCloseToSubmitMs : signalToSubmitMs != null && signalToSubmitMs >= 0 ? signalToSubmitMs : null;
+  const candles = getSignalCandles(signal, interval);
+  const currentDelayRiskBps = roundMetric(
+    (0, import_trade.calculateDelayRiskBps)({
+      candles,
+      intervalMs
+    })
+  );
+  const rawConfiguredDelayRiskBps = roundMetric(
+    (0, import_trade.calculateDelayRiskBps)({
+      candles,
+      intervalMs,
+      multiplier: 1,
+      maxBps: Number.POSITIVE_INFINITY
+    })
+  );
+  const rawObservedDelayRiskBps = roundMetric(
+    (0, import_trade.calculateDelayRiskBps)({
+      candles,
+      intervalMs,
+      expectedDelayMs: observedDelayMs,
+      multiplier: 1,
+      maxBps: Number.POSITIVE_INFINITY
+    })
+  );
+  const signalToArrivalAdverseBps = adverseEntryBps({
+    direction,
+    expectedPrice: signalClosePrice,
+    actualPrice: arrivalMid
+  });
+  const arrivalToFillAdverseBps = adverseEntryBps({
+    direction,
+    expectedPrice: arrivalMid,
+    actualPrice: fillAvgPrice
+  });
+  const signalToFillAdverseBps = adverseEntryBps({
+    direction,
+    expectedPrice: signalClosePrice,
+    actualPrice: fillAvgPrice
+  });
+  const currentModelEntrySlippageBps = signalToFillAdverseBps != null ? roundMetric(
+    import_constants.BACKTEST_BASE_SLIPPAGE_BPS + (spreadBps ?? 0) * import_constants.BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER + import_constants.BACKTEST_MARKET_IMPACT_BPS + (currentDelayRiskBps ?? 0)
+  ) : null;
+  const residualVsCurrentModelBps = signalToFillAdverseBps != null && currentModelEntrySlippageBps != null ? roundMetric(signalToFillAdverseBps - currentModelEntrySlippageBps) : null;
+  return {
+    strategy,
+    symbol,
+    interval,
+    direction,
+    orderId,
+    signalId,
+    qty,
+    signalTimestamp,
+    signalCloseTimestamp,
+    signalClosePrice,
+    arrivalSnapshotTime,
+    arrivalSource,
+    arrivalMid,
+    bid,
+    ask,
+    spreadBps,
+    orderSubmitTime,
+    orderAckTime,
+    fillAvgPrice,
+    fillSource,
+    fillTime,
+    telemetryQuality,
+    fee,
+    feeBps: feeBps({ fee, fillAvgPrice, qty }),
+    arrivalSnapshotAgeMs,
+    signalToSubmitMs,
+    signalCloseToSubmitMs,
+    submitToAckMs,
+    submitToFillMs,
+    orderAckToFillMs,
+    signalToFillMs,
+    signalToArrivalAdverseBps,
+    arrivalToFillAdverseBps,
+    signalToFillAdverseBps,
+    currentDelayRiskBps,
+    rawConfiguredDelayRiskBps,
+    rawObservedDelayRiskBps,
+    currentModelEntrySlippageBps,
+    residualVsCurrentModelBps,
+    replayEntryResidualBps: adverseEntryBps({
+      direction: direction ?? match?.direction ?? null,
+      expectedPrice: match?.backtestPrice ?? null,
+      actualPrice: match?.runtimePrice ?? null
+    }),
+    runtimeLineage: row.runtimeLineage
+  };
+};
+var buildReplayOnlySample = (match) => ({
+  strategy: match.strategy,
+  symbol: match.symbol,
+  interval: null,
+  direction: match.direction,
+  orderId: match.orderLinkId ?? match.orderId,
+  signalId: match.signalId,
+  qty: null,
+  signalTimestamp: null,
+  signalCloseTimestamp: null,
+  signalClosePrice: null,
+  arrivalSnapshotTime: null,
+  arrivalSource: null,
+  arrivalMid: null,
+  bid: null,
+  ask: null,
+  spreadBps: null,
+  orderSubmitTime: null,
+  orderAckTime: null,
+  fillAvgPrice: match.runtimePrice,
+  fillSource: "replay_runtime_price",
+  fillTime: null,
+  telemetryQuality: match.runtimePrice != null ? "price_only" : "none",
+  fee: null,
+  feeBps: null,
+  arrivalSnapshotAgeMs: null,
+  signalToSubmitMs: null,
+  signalCloseToSubmitMs: null,
+  submitToAckMs: null,
+  submitToFillMs: null,
+  orderAckToFillMs: null,
+  signalToFillMs: null,
+  signalToArrivalAdverseBps: null,
+  arrivalToFillAdverseBps: null,
+  signalToFillAdverseBps: null,
+  currentDelayRiskBps: null,
+  rawConfiguredDelayRiskBps: null,
+  rawObservedDelayRiskBps: null,
+  currentModelEntrySlippageBps: null,
+  residualVsCurrentModelBps: null,
+  replayEntryResidualBps: adverseEntryBps({
+    direction: match.direction,
+    expectedPrice: match.backtestPrice,
+    actualPrice: match.runtimePrice
+  }),
+  runtimeLineage: null
+});
+var hasTelemetry = (sample) => sample.signalClosePrice != null || sample.arrivalMid != null || sample.orderSubmitTime != null || sample.fillAvgPrice != null || sample.fillTime != null || sample.fee != null;
+var hasFullTelemetry = (sample) => sample.signalClosePrice != null && sample.arrivalMid != null && sample.orderSubmitTime != null && sample.orderAckTime != null && sample.fillAvgPrice != null && sample.fillTime != null;
+var buildGroupSummary = (samples) => ({
+  trades: samples.length,
+  fullTelemetryTrades: samples.filter(hasFullTelemetry).length,
+  replayMatchedTrades: metricValues(samples, "replayEntryResidualBps").length,
+  telemetryQuality: countBy(samples, (sample) => sample.telemetryQuality),
+  fillSource: countBy(samples, (sample) => sample.fillSource),
+  arrivalSource: countBy(samples, (sample) => sample.arrivalSource),
+  signalToArrivalAdverseBps: summarizeNumbers(
+    metricValues(samples, "signalToArrivalAdverseBps")
+  ),
+  arrivalToFillAdverseBps: summarizeNumbers(
+    metricValues(samples, "arrivalToFillAdverseBps")
+  ),
+  signalToFillAdverseBps: summarizeNumbers(
+    metricValues(samples, "signalToFillAdverseBps")
+  ),
+  residualVsCurrentModelBps: summarizeNumbers(
+    metricValues(samples, "residualVsCurrentModelBps")
+  ),
+  replayEntryResidualBps: summarizeNumbers(
+    metricValues(samples, "replayEntryResidualBps")
+  ),
+  spreadBps: summarizeNumbers(metricValues(samples, "spreadBps")),
+  feeBps: summarizeNumbers(metricValues(samples, "feeBps")),
+  arrivalSnapshotAgeMs: summarizeNumbers(
+    metricValues(samples, "arrivalSnapshotAgeMs")
+  ),
+  signalToSubmitMs: summarizeNumbers(metricValues(samples, "signalToSubmitMs")),
+  signalCloseToSubmitMs: summarizeNumbers(
+    metricValues(samples, "signalCloseToSubmitMs")
+  ),
+  submitToAckMs: summarizeNumbers(metricValues(samples, "submitToAckMs")),
+  submitToFillMs: summarizeNumbers(metricValues(samples, "submitToFillMs")),
+  orderAckToFillMs: summarizeNumbers(metricValues(samples, "orderAckToFillMs")),
+  currentDelayRiskBps: summarizeNumbers(
+    metricValues(samples, "currentDelayRiskBps")
+  ),
+  rawConfiguredDelayRiskBps: summarizeNumbers(
+    metricValues(samples, "rawConfiguredDelayRiskBps")
+  ),
+  rawObservedDelayRiskBps: summarizeNumbers(
+    metricValues(samples, "rawObservedDelayRiskBps")
+  )
+});
+var groupSamples = (samples, keyGetter) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const sample of samples) {
+    const key = keyGetter(sample);
+    if (!key) {
+      continue;
+    }
+    groups.set(key, [...groups.get(key) ?? [], sample]);
+  }
+  return Object.fromEntries(
+    [...groups.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([key, group]) => [key, buildGroupSummary(group)])
+  );
+};
+var positiveMetricValues = (samples, key) => metricValues(samples, key).filter((value) => value > 0);
+var buildRecommendation = (samples) => {
+  const fullTelemetrySamples = samples.filter(hasFullTelemetry);
+  const notes = [];
+  if (!fullTelemetrySamples.length) {
+    return {
+      confidence: "none",
+      baseSlippageBps: null,
+      spreadMultiplier: null,
+      delayRiskMultiplier: null,
+      delayRiskMaxBps: null,
+      expectedDelayMs: null,
+      notes: [
+        "No full live execution telemetry was found. Use a newer runtime debug artifact collected after telemetry persistence was enabled.",
+        "Replay residuals can still diagnose model drift, but they are not enough to calibrate signal-to-arrival and arrival-to-fill components separately."
+      ]
+    };
+  }
+  if (fullTelemetrySamples.length < 20) {
+    notes.push(
+      "Sample is small; treat recommendations as diagnostic until at least 20-50 live fills are available."
+    );
+  }
+  const spreadRatios = fullTelemetrySamples.map((sample) => {
+    if (sample.arrivalToFillAdverseBps == null || sample.spreadBps == null || sample.spreadBps <= 0) {
+      return null;
+    }
+    return Math.max(0, sample.arrivalToFillAdverseBps) / sample.spreadBps;
+  }).filter(
+    (value) => value != null && Number.isFinite(value)
+  );
+  const spreadMultiplier = roundMetric(quantile(spreadRatios, 0.75), 4);
+  const baseResiduals = fullTelemetrySamples.map((sample) => {
+    if (sample.arrivalToFillAdverseBps == null) {
+      return null;
+    }
+    return Math.max(
+      0,
+      sample.arrivalToFillAdverseBps - (sample.spreadBps ?? 0) * (spreadMultiplier ?? import_constants.BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER)
+    );
+  }).filter(
+    (value) => value != null && Number.isFinite(value)
+  );
+  const closeDelayMs = positiveMetricValues(
+    fullTelemetrySamples,
+    "signalCloseToSubmitMs"
+  );
+  const fallbackDelayMs = positiveMetricValues(
+    fullTelemetrySamples,
+    "signalToSubmitMs"
+  );
+  if (!spreadRatios.length) {
+    notes.push(
+      "Spread multiplier could not be calibrated because spreadBps or arrival-to-fill telemetry is missing."
+    );
+  }
+  notes.push(
+    "Delay risk bps is disabled; signal-to-arrival latency is modeled by next-bar-open backtest fills."
+  );
+  return {
+    confidence: fullTelemetrySamples.length >= 50 ? "high" : fullTelemetrySamples.length >= 20 ? "medium" : "low",
+    baseSlippageBps: roundMetric(quantile(baseResiduals, 0.75), 2),
+    spreadMultiplier,
+    delayRiskMultiplier: null,
+    delayRiskMaxBps: null,
+    expectedDelayMs: roundMetric(
+      quantile(closeDelayMs.length ? closeDelayMs : fallbackDelayMs, 0.5),
+      0
+    ),
+    notes
+  };
+};
+var buildExecutionCalibrationReport = ({
+  runtimeArtifact,
+  replayEvidenceArtifact,
+  sourcePaths = {},
+  nowMs = Date.now()
+}) => {
+  const runtimePayload2 = getRuntimePayload({
+    runtimeArtifact,
+    replayEvidenceArtifact
+  });
+  const runtimeRows = extractRuntimeTradeRows(runtimePayload2);
+  const replayMatches = extractReplayMatches(replayEvidenceArtifact);
+  const replayMaps = buildReplayMatchMaps(replayMatches);
+  const usedReplayMatches = /* @__PURE__ */ new Set();
+  const samples = runtimeRows.map((row) => {
+    const orderId = finiteString(row.trade.orderId);
+    const signalId = finiteString(row.trade.signalId);
+    const match = (orderId ? replayMaps.byOrderId.get(orderId) ?? null : null) ?? (signalId ? replayMaps.bySignalId.get(signalId) ?? null : null);
+    if (match) {
+      usedReplayMatches.add(match);
+    }
+    return buildSample({ row, match });
+  });
+  const replayOnlySamples = replayMatches.filter((match) => !usedReplayMatches.has(match)).map(buildReplayOnlySample);
+  return {
+    reportType: "execution-calibration",
+    generatedAt: nowMs,
+    sources: sourcePaths,
+    currentModel: {
+      baseSlippageBps: import_constants.BACKTEST_BASE_SLIPPAGE_BPS,
+      spreadMultiplier: import_constants.BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+      marketImpactBps: import_constants.BACKTEST_MARKET_IMPACT_BPS
+    },
+    counts: {
+      runtimeTrades: runtimeRows.length,
+      telemetryTrades: samples.filter(hasTelemetry).length,
+      fullTelemetryTrades: samples.filter(hasFullTelemetry).length,
+      replayMatched: replayMatches.length,
+      replayMatchedRuntimeTrades: usedReplayMatches.size,
+      replayOnlyMatches: replayOnlySamples.length
+    },
+    summary: {
+      all: buildGroupSummary([...samples, ...replayOnlySamples]),
+      byStrategy: groupSamples(
+        [...samples, ...replayOnlySamples],
+        (sample) => sample.strategy
+      ),
+      bySymbol: groupSamples(samples, (sample) => sample.symbol),
+      byInterval: groupSamples(samples, (sample) => sample.interval),
+      byTelemetryQuality: groupSamples(
+        [...samples, ...replayOnlySamples],
+        (sample) => sample.telemetryQuality
+      ),
+      byFillSource: groupSamples(
+        [...samples, ...replayOnlySamples],
+        (sample) => sample.fillSource
+      ),
+      byLatencyBucket: groupSamples(samples, toLatencyBucket),
+      bySpreadBucket: groupSamples(samples, toSpreadBucket)
+    },
+    recommendation: buildRecommendation(samples),
+    samples,
+    replayOnlySamples
+  };
+};
+
+// src/lib/runtimeLineage.ts
+var import_node_crypto = require("crypto");
+var normalizeForStableJson = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeForStableJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+    );
+  }
+  return value;
+};
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var runtimeLineageKey = (lineage) => [
+  "v3",
+  lineage.deploymentCompositionId,
+  lineage.strategyRevision,
+  lineage.strategyPackageVersion,
+  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
+  lineage.runtimePackageVersion
+].join(":");
+
+// src/lib/runtimeEvidenceDeployment.ts
+var runtimeEvidenceDeployment_exports = {};
+__reExport(runtimeEvidenceDeployment_exports, require("@tradejs/node/diagnostics"));
+
+// src/lib/runtimeScorecard.ts
+var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var asArray2 = (value) => Array.isArray(value) ? value : [];
+var finiteNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var finiteString2 = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var packageVersionMap = (value) => {
+  const record = asRecord2(value);
+  if (!record || Object.keys(record).length === 0) return null;
+  const entries = Object.entries(record);
+  if (entries.some(
+    ([name, version]) => !name.startsWith("@tradejs/") || finiteString2(version) == null
+  )) {
+    return null;
+  }
+  return Object.fromEntries(
+    entries.map(([name, version]) => [name, String(version).trim()]).sort(([left], [right]) => left.localeCompare(right))
+  );
+};
+var round = (value, decimals = 6) => Number(value.toFixed(decimals));
+var unwrapRows = (value, key) => asArray2(value).map((item) => asRecord2(asRecord2(item)?.[key]) ?? asRecord2(item)).filter((item) => item != null);
+var runtimePayload = (artifact) => {
+  const root = asRecord2(artifact) ?? {};
+  return asRecord2(root.runtime) ?? root;
+};
+var runtimeWindow = (artifact) => {
+  const root = asRecord2(artifact) ?? {};
+  return asRecord2(root.window) ?? asRecord2(runtimePayload(artifact).window) ?? {};
+};
+var extractRuntimeRows = (artifact) => {
+  const runtime = runtimePayload(artifact);
+  return {
+    evaluations: unwrapRows(runtime.evaluations, "evaluation"),
+    signals: unwrapRows(runtime.signals, "signal"),
+    trades: unwrapRows(runtime.trades, "trade"),
+    lineageScopes: unwrapRows(runtime.lineageScopes, "lineageScope")
+  };
+};
+var buildEmbeddedLineageScope = ({
+  artifact,
+  rows,
+  strategy
+}) => {
+  const deployment = asRecord2(asRecord2(artifact)?.deployment);
+  if (finiteNumber2(deployment?.schemaVersion) !== 2) return null;
+  const deploymentId = finiteString2(deployment?.id);
+  const accountId = finiteString2(deployment?.accountId);
+  const deploymentCompositionId = finiteString2(
+    deployment?.deploymentCompositionId
+  );
+  if (!deploymentId || !accountId || !deploymentCompositionId) return null;
+  const snapshots = asArray2(deployment?.strategies).map(asRecord2).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+    (item) => !strategy || finiteString2(item.strategyName) === strategy
+  );
+  const targetSeeds = snapshots.map((snapshot) => {
+    const strategyName = finiteString2(snapshot.strategyName);
+    const strategyRevision = finiteString2(snapshot.strategyRevision);
+    const strategyPackageVersion = finiteString2(
+      snapshot.strategyPackageVersion
+    );
+    const strategyDependencyVersions = packageVersionMap(
+      snapshot.strategyDependencyVersions
+    );
+    const runtimePackageVersion = finiteString2(
+      snapshot.runtimePackageVersion
+    );
+    return strategyName && strategyRevision && strategyPackageVersion && strategyDependencyVersions && runtimePackageVersion ? {
+      strategyName,
+      strategyRevision,
+      deploymentCompositionId,
+      strategyPackageVersion,
+      strategyDependencyVersions,
+      runtimePackageVersion
+    } : null;
+  }).filter((item) => item != null);
+  if (targetSeeds.length !== snapshots.length || targetSeeds.length === 0) {
+    return null;
+  }
+  const lineageRows = [
+    ...rows.evaluations,
+    ...rows.signals,
+    ...rows.trades,
+    ...rows.lineageScopes.map((scope) => ({
+      strategy: scope.strategy,
+      deploymentId: scope.deploymentId,
+      accountId: scope.accountId,
+      runtimeLineage: scope.lineage
+    }))
+  ];
+  const identityMatches = (lineage, target) => finiteNumber2(lineage?.schemaVersion) === 3 && finiteString2(lineage?.strategyRevision) === target.strategyRevision && finiteString2(lineage?.deploymentCompositionId) === target.deploymentCompositionId && finiteString2(lineage?.strategyPackageVersion) === target.strategyPackageVersion && JSON.stringify(packageVersionMap(lineage?.strategyDependencyVersions)) === JSON.stringify(target.strategyDependencyVersions) && finiteString2(lineage?.runtimePackageVersion) === target.runtimePackageVersion;
+  const targets = /* @__PURE__ */ new Map();
+  for (const seed of targetSeeds) {
+    const matchingRows = lineageRows.filter(
+      (row) => finiteString2(row.strategy) === seed.strategyName && finiteString2(row.deploymentId) === deploymentId && finiteString2(row.accountId) === accountId && identityMatches(asRecord2(row.runtimeLineage), seed)
+    );
+    const riskValues = new Set(
+      matchingRows.map((row) => finiteNumber2(asRecord2(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
+    );
+    targets.set(seed.strategyName, {
+      ...seed,
+      maxLossValue: riskValues.size === 1 ? [...riskValues][0] : null,
+      rowsWithLineage: matchingRows.length,
+      riskConflict: riskValues.size > 1
+    });
+  }
+  const belongs = (row) => {
+    const strategyName = finiteString2(row.strategy);
+    const target = strategyName ? targets.get(strategyName) : null;
+    const lineage = asRecord2(row.runtimeLineage);
+    return Boolean(
+      target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber2(lineage?.maxLossValue) === target.maxLossValue
+    );
+  };
+  const targetValues = [...targets.values()];
+  const coverageComplete = targetValues.every(
+    (target) => target.rowsWithLineage > 0 && target.maxLossValue != null
+  );
+  const commonRiskValues = new Set(
+    targetValues.map((target) => target.maxLossValue).filter((value) => value != null)
+  );
+  const singleTarget = targetValues.length === 1 ? targetValues[0] : null;
+  const singleLineage = singleTarget?.maxLossValue != null ? {
+    schemaVersion: 3,
+    strategyRevision: singleTarget.strategyRevision,
+    deploymentCompositionId: singleTarget.deploymentCompositionId,
+    strategyPackageVersion: singleTarget.strategyPackageVersion,
+    strategyDependencyVersions: singleTarget.strategyDependencyVersions,
+    runtimePackageVersion: singleTarget.runtimePackageVersion,
+    maxLossValue: singleTarget.maxLossValue
+  } : null;
+  return {
+    belongs,
+    summary: {
+      complete: coverageComplete,
+      identityComplete: true,
+      coverageComplete,
+      conflicts: targetValues.some((target) => target.riskConflict),
+      rows: lineageRows.length,
+      rowsWithLineage: targetValues.reduce(
+        (total, target) => total + target.rowsWithLineage,
+        0
+      ),
+      schemaVersion: 3,
+      lineageKey: singleLineage ? runtimeLineageKey(singleLineage) : null,
+      strategyRevision: singleTarget?.strategyRevision ?? null,
+      deploymentCompositionId,
+      strategyPackageVersion: singleTarget?.strategyPackageVersion ?? null,
+      strategyDependencyVersions: singleTarget?.strategyDependencyVersions ?? null,
+      runtimePackageVersion: singleTarget?.runtimePackageVersion ?? null,
+      maxLossValue: commonRiskValues.size === 1 ? [...commonRiskValues][0] : null,
+      strategyScopes: Object.fromEntries(
+        targetValues.map((target) => [
+          target.strategyName,
+          {
+            strategyRevision: target.strategyRevision,
+            rowsWithLineage: target.rowsWithLineage,
+            maxLossValue: target.maxLossValue,
+            complete: target.rowsWithLineage > 0 && target.maxLossValue != null
+          }
+        ])
+      )
+    }
+  };
+};
+var runtimeDeploymentBinding = (artifact) => {
+  const deployment = asRecord2(asRecord2(artifact)?.deployment);
+  return {
+    deploymentId: finiteString2(deployment?.id),
+    accountId: finiteString2(deployment?.accountId)
+  };
+};
+var belongsToRuntimeDeployment = (row, binding) => binding.deploymentId == null && binding.accountId == null ? true : finiteString2(row.deploymentId) === binding.deploymentId && finiteString2(row.accountId) === binding.accountId;
+var belongsToStrategy = (row, strategy) => strategy == null || finiteString2(row.strategy) === strategy;
+var filterArtifactByStrategy = (artifact, strategy) => {
+  if (!strategy) return artifact;
+  const root = asRecord2(artifact) ?? {};
+  const runtime = runtimePayload(artifact);
+  return {
+    ...root,
+    runtime: {
+      ...runtime,
+      evaluations: asArray2(runtime.evaluations).filter(
+        (item) => belongsToStrategy(
+          asRecord2(asRecord2(item)?.evaluation) ?? asRecord2(item) ?? {},
+          strategy
+        )
+      ),
+      signals: asArray2(runtime.signals).filter(
+        (item) => belongsToStrategy(
+          asRecord2(asRecord2(item)?.signal) ?? asRecord2(item) ?? {},
+          strategy
+        )
+      ),
+      trades: asArray2(runtime.trades).filter(
+        (item) => belongsToStrategy(
+          asRecord2(asRecord2(item)?.trade) ?? asRecord2(item) ?? {},
+          strategy
+        )
+      ),
+      lineageScopes: asArray2(runtime.lineageScopes).filter(
+        (item) => belongsToStrategy(asRecord2(item) ?? {}, strategy)
+      )
+    }
+  };
+};
+var countBy2 = (items, getter) => {
+  const counts = {};
+  for (const item of items) {
+    const key = getter(item);
+    if (!key) continue;
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(counts).sort(([left], [right]) => left.localeCompare(right))
+  );
+};
+var resolveGateDecision = (evaluation) => {
+  const analysis = asRecord2(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;
+};
+var buildDistributions = ({
+  evaluations,
+  signals
+}) => {
+  const candidates = evaluations.filter(
+    (evaluation) => evaluation.status === "signal"
+  );
+  return {
+    candidatesByStrategy: countBy2(
+      candidates,
+      (evaluation) => finiteString2(evaluation.strategy)
+    ),
+    orderStatus: countBy2(signals, (signal) => finiteString2(signal.orderStatus)),
+    skipReasons: countBy2(
+      signals,
+      (signal) => finiteString2(signal.orderSkipReason)
+    ),
+    aiQuality: countBy2(candidates, (evaluation) => {
+      const quality = finiteNumber2(asRecord2(evaluation.aiAnalysis)?.quality);
+      return quality == null ? null : String(quality);
+    })
+  };
+};
+var buildDistributionDelta = (current, previous) => {
+  const currentTotal = Object.values(current).reduce(
+    (total, value) => total + value,
+    0
+  );
+  const previousTotal = Object.values(previous).reduce(
+    (total, value) => total + value,
+    0
+  );
+  const keys = [
+    .../* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(previous)])
+  ].sort((left, right) => left.localeCompare(right));
+  return Object.fromEntries(
+    keys.map((key) => {
+      const currentCount = current[key] ?? 0;
+      const previousCount = previous[key] ?? 0;
+      const currentShare = currentTotal > 0 ? currentCount / currentTotal : 0;
+      const previousShare = previousTotal > 0 ? previousCount / previousTotal : 0;
+      return [
+        key,
+        {
+          currentCount,
+          previousCount,
+          currentShare: round(currentShare),
+          previousShare: round(previousShare),
+          shareDelta: round(currentShare - previousShare)
+        }
+      ];
+    })
+  );
+};
+var sum = (values) => round(values.reduce((total, value) => total + (value ?? 0), 0));
+var tradeTimestamp = (trade) => finiteNumber2(trade.exitTimestamp) ?? finiteNumber2(trade.lastSyncedAt) ?? finiteNumber2(trade.entryTimestamp) ?? 0;
+var dedupeTrades = (artifacts) => {
+  const tradesByOrderId = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    for (const trade of extractRuntimeRows(artifact).trades) {
+      const orderId = finiteString2(trade.orderId);
+      if (!orderId) continue;
+      const existing = tradesByOrderId.get(orderId);
+      if (!existing || tradeTimestamp(trade) >= tradeTimestamp(existing)) {
+        tradesByOrderId.set(orderId, trade);
+      }
+    }
+  }
+  return [...tradesByOrderId.values()];
+};
+var maxDrawdown = (trades) => {
+  let cumulative = 0;
+  let peak = 0;
+  let drawdown = 0;
+  for (const trade of trades.sort(
+    (left, right) => tradeTimestamp(left) - tradeTimestamp(right)
+  )) {
+    cumulative += finiteNumber2(trade.closedPnl) ?? 0;
+    peak = Math.max(peak, cumulative);
+    drawdown = Math.max(drawdown, peak - cumulative);
+  }
+  return round(drawdown);
+};
+var buildRollingPerformance = ({
+  trades,
+  anchorTime,
+  days
+}) => {
+  const startTime = anchorTime - days * 24 * 60 * 60 * 1e3;
+  const closed = trades.filter((trade) => {
+    const exitTimestamp = finiteNumber2(trade.exitTimestamp);
+    return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < anchorTime;
+  });
+  const realizedPnl = sum(closed.map((trade) => finiteNumber2(trade.closedPnl)));
+  return {
+    days,
+    closedTrades: closed.length,
+    realizedPnl,
+    expectancy: closed.length > 0 ? round(realizedPnl / closed.length) : null,
+    maxDrawdown: maxDrawdown(closed)
+  };
+};
+var getReplayComparison = (artifact) => {
+  const root = asRecord2(artifact) ?? {};
+  return asRecord2(asRecord2(root.replay)?.runtimeComparison) ?? null;
+};
+var replayCountsForStrategy = (replayComparison, strategy) => {
+  if (strategy) {
+    const byStrategy = asRecord2(replayComparison?.byStrategy);
+    const strategyCounts = asRecord2(byStrategy?.[strategy]);
+    if (strategyCounts) {
+      return {
+        matched: finiteNumber2(strategyCounts.matched) ?? 0,
+        backtestOnly: finiteNumber2(strategyCounts.backtestOnly) ?? 0,
+        runtimeOnly: finiteNumber2(strategyCounts.runtimeOnly) ?? 0
+      };
+    }
+  }
+  const counts = asRecord2(replayComparison?.counts);
+  return {
+    matched: finiteNumber2(counts?.matched) ?? 0,
+    backtestOnly: finiteNumber2(counts?.backtestOnly) ?? 0,
+    runtimeOnly: finiteNumber2(counts?.runtimeOnly) ?? 0
+  };
+};
+var getProspectiveSummary = (artifact) => {
+  const root = asRecord2(artifact);
+  if (!root || root.reportType !== "strategy-prospective-evidence") return null;
+  return {
+    rawCoreExpectancy: finiteNumber2(root.rawCoreExpectancy),
+    aiGateExpectancy: finiteNumber2(root.aiGateExpectancy),
+    regimeCoverage: finiteNumber2(root.regimeCoverage)
+  };
+};
+var buildRuntimeScorecard = ({
+  runtimeArtifact,
+  replayEvidenceArtifact,
+  calibrationArtifact,
+  prospectiveEvidenceArtifact,
+  historyRuntimeArtifacts = [],
+  thresholds = {
+    minimumParityRatio: 0.95,
+    maximumSlippageResidualBps: 3,
+    minimumClosedTrades: 20,
+    minimumExpectancy: 0
+  },
+  generatedAt = Date.now(),
+  strategy = null,
+  llmComparatorPolicy = "ai_approved_only"
+}) => {
+  (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(runtimeArtifact);
+  for (const artifact of historyRuntimeArtifacts) {
+    (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(artifact);
+  }
+  const scopedRuntimeArtifact = filterArtifactByStrategy(
+    runtimeArtifact,
+    strategy
+  );
+  const scopedHistoryArtifacts = historyRuntimeArtifacts.map(
+    (artifact) => filterArtifactByStrategy(artifact, strategy)
+  );
+  const deploymentBinding = runtimeDeploymentBinding(runtimeArtifact);
+  const rows = extractRuntimeRows(scopedRuntimeArtifact);
+  const embeddedLineageScope = buildEmbeddedLineageScope({
+    artifact: runtimeArtifact,
+    rows,
+    strategy
+  });
+  if (!embeddedLineageScope) {
+    throw new Error(
+      "Runtime scorecard requires the current embedded deployment lineage"
+    );
+  }
+  const runtimeLineage = embeddedLineageScope.summary;
+  const window = runtimeWindow(runtimeArtifact);
+  const startTime = finiteNumber2(window.startTime) ?? generatedAt - 864e5;
+  const endTime = finiteNumber2(window.endTime) ?? generatedAt;
+  const signalEvaluations = rows.evaluations.filter(
+    (evaluation) => evaluation.status === "signal"
+  );
+  const gateDecisions = signalEvaluations.map(resolveGateDecision).filter(
+    (decision) => Boolean(decision)
+  );
+  const llmEligibleEvaluations = llmComparatorPolicy === "disabled" ? [] : llmComparatorPolicy === "ai_approved_only" ? signalEvaluations.filter(
+    (evaluation) => resolveGateDecision(evaluation)?.decision === "approved"
+  ) : signalEvaluations;
+  const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
+    const analysis = asRecord2(evaluation.aiAnalysis);
+    const gateDecision = resolveGateDecision(evaluation)?.decision ?? null;
+    const llmDecision = finiteString2(analysis?.llmDecision);
+    if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
+      return null;
+    }
+    return { gateDecision, llmDecision };
+  }).filter(
+    (comparison) => Boolean(comparison)
+  );
+  const allocatorDecisions = signalEvaluations.map((evaluation) => asRecord2(evaluation.allocatorDecision)).filter((item) => item != null);
+  const riskDecisions = signalEvaluations.map((evaluation) => asRecord2(evaluation.riskDecision)).filter((item) => item != null);
+  const orderAttempts = rows.signals.filter(
+    (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed"
+  );
+  const currentClosedTrades = rows.trades.filter((trade) => {
+    const exitTimestamp = finiteNumber2(trade.exitTimestamp);
+    return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
+  });
+  const replayComparison = getReplayComparison(replayEvidenceArtifact);
+  const replayCounts = replayCountsForStrategy(replayComparison, strategy);
+  const matched = replayCounts.matched;
+  const backtestOnly = replayCounts.backtestOnly;
+  const runtimeOnly = replayCounts.runtimeOnly;
+  const comparisonTotal = matched + backtestOnly + runtimeOnly;
+  const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
+  const lineage = asRecord2(replayComparison?.lineage);
+  const lineageReason = finiteString2(lineage?.reason);
+  const calibrationRoot = asRecord2(calibrationArtifact) ?? {};
+  const calibrationSamples = asArray2(calibrationRoot.samples).map(asRecord2).filter((item) => item != null).filter((item) => !strategy || finiteString2(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
+  const averageSampleMetric = (field) => {
+    const values = calibrationSamples.map((sample) => finiteNumber2(sample[field])).filter((value) => value != null);
+    return values.length ? round(sum(values) / values.length) : null;
+  };
+  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) => finiteNumber2(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,
+    scopedRuntimeArtifact
+  ]);
+  const comparableHistoryTrades = historyTrades.filter(
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
+  );
+  const comparableCurrentClosedTrades = currentClosedTrades.filter(
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
+  );
+  const comparableFills = rows.trades.filter(
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
+  );
+  const currentDistributions = buildDistributions(rows);
+  const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
+    const candidateEndTime = finiteNumber2(candidateWindow.endTime);
+    return candidateEndTime != null && candidateEndTime <= startTime;
+  }).sort(
+    (left, right) => (finiteNumber2(right.window.endTime) ?? 0) - (finiteNumber2(left.window.endTime) ?? 0)
+  )[0];
+  const previousDistributions = previousArtifact ? buildDistributions(extractRuntimeRows(previousArtifact.artifact)) : null;
+  const rolling = [7, 30, 90].map(
+    (days) => buildRollingPerformance({
+      trades: [...comparableHistoryTrades],
+      anchorTime: endTime,
+      days
+    })
+  );
+  const sevenDay = rolling[0];
+  const reactions = [];
+  if (lineageReason) {
+    reactions.push({
+      code: "LINEAGE_NOT_COMPARABLE",
+      severity: "blocking",
+      message: lineageReason
+    });
+  }
+  if (!runtimeLineage.complete) {
+    reactions.push({
+      code: "RUNTIME_LINEAGE_INCOMPLETE",
+      severity: "blocking",
+      message: "Runtime rows do not share one complete composition lineage."
+    });
+  }
+  if (parityRatio != null && parityRatio < thresholds.minimumParityRatio) {
+    reactions.push({
+      code: "PARITY_REGRESSION",
+      severity: "blocking",
+      message: `Parity ${round(parityRatio * 100, 2)}% is below ${round(thresholds.minimumParityRatio * 100, 2)}%.`
+    });
+  }
+  if (residualVsModelBps != null && residualVsModelBps > thresholds.maximumSlippageResidualBps) {
+    reactions.push({
+      code: "SLIPPAGE_DRIFT",
+      severity: "warning",
+      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) {
+    reactions.push({
+      code: "EXPECTANCY_DEGRADATION",
+      severity: "blocking",
+      message: `7d expectancy ${sevenDay.expectancy} is below ${thresholds.minimumExpectancy}.`
+    });
+  }
+  if (sevenDay.closedTrades < thresholds.minimumClosedTrades) {
+    reactions.push({
+      code: "INSUFFICIENT_RECENT_SAMPLE",
+      severity: "info",
+      message: `Only ${sevenDay.closedTrades} closed trades in 7d; ${thresholds.minimumClosedTrades} required for expectancy reaction.`
+    });
+  }
+  const promotionStatus = reactions.some(
+    (reaction) => reaction.severity === "blocking"
+  ) ? "PROMOTION_BLOCKED" : reactions.some((reaction) => reaction.severity === "warning") ? "REVIEW_REQUIRED" : "OBSERVE";
+  return {
+    reportType: "runtime-scorecard",
+    schemaVersion: 1,
+    generatedAt,
+    window: { startTime, endTime },
+    strategy,
+    deployment: deploymentBinding,
+    lineage: runtimeLineage,
+    promotionStatus,
+    thresholds: {
+      ...thresholds,
+      maximumSignalCloseToSubmitMs
+    },
+    funnel: {
+      evaluations: rows.evaluations.length,
+      coreCandidates: signalEvaluations.length,
+      gate: {
+        available: gateDecisions.length > 0,
+        approved: gateDecisions.filter(
+          ({ decision }) => decision === "approved"
+        ).length,
+        rejected: gateDecisions.filter(
+          ({ decision }) => decision === "rejected"
+        ).length,
+        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.status === "approved"
+        ).length,
+        rejected: allocatorDecisions.filter(
+          (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.status === "approved"
+        ).length,
+        rejected: riskDecisions.filter(
+          (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(
+        (signal) => signal.orderStatus === "failed"
+      ).length,
+      balanceRejects: rows.signals.filter(
+        (signal) => /BALANCE|MARGIN/i.test(
+          `${finiteString2(signal.orderSkipReason) ?? ""} ${finiteString2(signal.orderFailureReason) ?? ""}`
+        )
+      ).length,
+      fills: comparableFills.length,
+      nonComparableFills: rows.trades.length - comparableFills.length,
+      closedTrades: currentClosedTrades.length,
+      comparableClosedTrades: comparableCurrentClosedTrades.length,
+      nonComparableClosedTrades: currentClosedTrades.length - comparableCurrentClosedTrades.length
+    },
+    realized: {
+      pnl: sum(
+        comparableCurrentClosedTrades.map(
+          (trade) => finiteNumber2(trade.closedPnl)
+        )
+      ),
+      fees: sum(
+        comparableCurrentClosedTrades.map(
+          (trade) => finiteNumber2(trade.totalFee)
+        )
+      ),
+      funding: sum(
+        comparableCurrentClosedTrades.map(
+          (trade) => finiteNumber2(trade.fundingFee)
+        )
+      )
+    },
+    gateComparison: {
+      policy: llmComparatorPolicy,
+      eligible: llmEligibleEvaluations.length,
+      compared: gateComparisons.length,
+      coverage: llmEligibleEvaluations.length ? round(gateComparisons.length / llmEligibleEvaluations.length) : null,
+      agreements: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === comparison.llmDecision
+      ).length,
+      disagreements: gateComparisons.filter(
+        (comparison) => comparison.gateDecision !== comparison.llmDecision
+      ).length,
+      gateApprovedLlmRejected: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === "approved" && comparison.llmDecision === "rejected"
+      ).length,
+      gateRejectedLlmApproved: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === "rejected" && comparison.llmDecision === "approved"
+      ).length
+    },
+    parity: {
+      available: comparisonTotal > 0,
+      matched,
+      backtestOnly,
+      runtimeOnly,
+      ratio: parityRatio == null ? null : round(parityRatio),
+      lineageReason
+    },
+    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,
+      signalToArrivalAdverseBps,
+      arrivalToFillAdverseBps,
+      averageSignalCloseToSubmitMs,
+      averageSubmitToFillMs
+    },
+    prospective,
+    rolling,
+    distributions: currentDistributions,
+    distributionChanges: {
+      available: previousDistributions != null,
+      baselineWindow: previousArtifact ? {
+        startTime: finiteNumber2(previousArtifact.window.startTime),
+        endTime: finiteNumber2(previousArtifact.window.endTime)
+      } : null,
+      metrics: previousDistributions ? Object.fromEntries(
+        Object.entries(currentDistributions).map(([name, current]) => [
+          name,
+          buildDistributionDelta(
+            current,
+            previousDistributions[name]
+          )
+        ])
+      ) : {}
+    },
+    reactions
+  };
+};
+var formatRuntimeScorecardMarkdown = (scorecard) => {
+  const rollingRows = scorecard.rolling.map(
+    (row) => `| ${row.days}d | ${row.closedTrades} | ${row.realizedPnl} | ${row.expectancy ?? "n/a"} | ${row.maxDrawdown} |`
+  ).join("\n");
+  const reactions = scorecard.reactions.length ? scorecard.reactions.map(
+    (reaction) => `- ${reaction.severity.toUpperCase()} \`${reaction.code}\`: ${reaction.message}`
+  ).join("\n") : "- No automatic reactions.";
+  const distributionChanges = Object.entries(
+    scorecard.distributionChanges.metrics
+  ).flatMap(
+    ([metric, values]) => Object.entries(values).map(([value, change]) => ({
+      metric,
+      value,
+      shareDelta: change.shareDelta
+    }))
+  ).sort(
+    (left, right) => Math.abs(right.shareDelta) - Math.abs(left.shareDelta)
+  ).slice(0, 10).map(
+    (change) => `- ${change.metric}.${change.value}: ${change.shareDelta >= 0 ? "+" : ""}${round(change.shareDelta * 100, 2)} pp`
+  ).join("\n");
+  return `# Runtime scorecard
+
+Status: **${scorecard.promotionStatus}**
+
+Window: ${new Date(scorecard.window.startTime).toISOString()} \u2014 ${new Date(scorecard.window.endTime).toISOString()}
+
+## Funnel
+
+- Evaluations: ${scorecard.funnel.evaluations}
+- Core candidates: ${scorecard.funnel.coreCandidates}
+- 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}
+- 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}
+
+## Replay and execution
+
+- Parity: ${scorecard.parity.ratio == null ? "n/a" : `${round(scorecard.parity.ratio * 100, 2)}%`}
+- Runtime/replay mismatches: ${scorecard.parity.backtestOnly + scorecard.parity.runtimeOnly}
+- 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
+
+| Window | Closed | Realized PnL | Expectancy | Max drawdown |
+| --- | ---: | ---: | ---: | ---: |
+${rollingRows}
+
+## Distribution changes
+
+${scorecard.distributionChanges.available ? distributionChanges || "- No distribution changes." : "- Previous comparable artifact is unavailable."}
+
+## Reactions
+
+${reactions}
+`;
+};
+
+// src/lib/runtimeEvidenceSync.ts
+var import_node_child_process = require("child_process");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_node_util = require("util");
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var runtimeEvidenceArtifacts_exports = {};
+__reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
+
+// src/lib/runtimeEvidenceSync.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var safeSegment = (value, fallback) => {
+  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+  return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+};
+var receiptPath = (receiptsRoot, artifactId) => import_node_path.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
+var markRuntimeEvidenceBundleProcessed = async ({
+  evidenceRoot,
+  deploymentId,
+  bundleDir,
+  scorecardPath,
+  runtimeFeedback
+}) => {
+  const safeDeploymentId = safeSegment(deploymentId, "production");
+  const verified = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir);
+  if (verified.manifest.deploymentId !== safeDeploymentId) {
+    throw new Error(
+      `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
+    );
+  }
+  const receiptsRoot = import_node_path.default.join(evidenceRoot, "receipts", safeDeploymentId);
+  const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
+  const temporaryPath = `${finalPath}.tmp-${process.pid}`;
+  const receipt = {
+    schemaVersion: runtimeFeedback ? 2 : 1,
+    artifactId: verified.manifest.artifactId,
+    payloadSha256: verified.manifest.payload.sha256,
+    processedAt: Date.now(),
+    scorecardPath: scorecardPath ?? null,
+    ...runtimeFeedback ? {
+      runtimeFeedbackArtifactId: runtimeFeedback.artifactId,
+      replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
+    } : {}
+  };
+  await import_promises.default.mkdir(receiptsRoot, { recursive: true });
+  await import_promises.default.writeFile(
+    temporaryPath,
+    `${JSON.stringify(receipt, null, 2)}
+`,
+    "utf8"
+  );
+  await import_promises.default.rename(temporaryPath, finalPath);
+  return finalPath;
+};
+
+// src/lib/runtimeFeedbackProcess.ts
+var processRuntimeFeedbackPair = async ({
+  runtimeDir,
+  replayDir,
+  evidenceRoot,
+  outputRoot,
+  historyDir
+}) => {
+  const { runtimeEvidence, feedback } = await (0, import_diagnostics.verifyRuntimeFeedbackReplaySource)(
+    { bundleDir: replayDir, runtimeEvidenceBundleDir: runtimeDir }
+  );
+  const { artifactId, deploymentId } = runtimeEvidence.manifest;
+  const snapshot = (0, import_diagnostics.parseRuntimeEvidenceDeploymentSnapshot)(
+    runtimeEvidence.artifact.deployment
+  );
+  if (!snapshot)
+    throw new Error("Runtime evidence requires a deployment snapshot");
+  const strategies = (0, import_diagnostics.activeRuntimeEvidenceStrategies)(snapshot);
+  for (const segment of [
+    artifactId,
+    deploymentId,
+    ...strategies.map((s) => s.strategyName)
+  ]) {
+    if (!/^[A-Za-z0-9._:-]+$/.test(segment) || segment === "." || segment === "..")
+      throw new Error("Invalid feedback output path identity");
+  }
+  const receiptPath2 = import_node_path2.default.join(
+    evidenceRoot,
+    "receipts",
+    deploymentId,
+    `${artifactId}.json`
+  );
+  await import_promises2.default.mkdir(import_node_path2.default.dirname(receiptPath2), { recursive: true });
+  const lock = receiptPath2 + ".processing";
+  await import_promises2.default.mkdir(lock);
+  try {
+    const previous = await import_promises2.default.readFile(receiptPath2, "utf8").catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+      return null;
+    });
+    if (previous) {
+      const receipt = JSON.parse(previous);
+      if (!receipt || typeof receipt !== "object" || !("schemaVersion" in receipt) || receipt.schemaVersion !== 2 || !("payloadSha256" in receipt) || !("runtimeFeedbackArtifactId" in receipt) || !("replayEvidenceSha256" in receipt) || !("scorecardPath" in receipt) || receipt.payloadSha256 !== runtimeEvidence.manifest.payload.sha256 || receipt.runtimeFeedbackArtifactId !== feedback.manifest.artifactId || receipt.replayEvidenceSha256 !== feedback.manifest.payloads.replayEvidence.sha256 || typeof receipt.scorecardPath !== "string")
+        throw new Error("Processing receipt conflicts with the exact pair");
+      await import_promises2.default.access(receipt.scorecardPath);
+      return {
+        processed: false,
+        receiptPath: receiptPath2,
+        scorecardPath: receipt.scorecardPath
+      };
+    }
+    const history = [];
+    if (historyDir)
+      for (const directory of await (0, import_diagnostics.discoverRuntimeEvidenceBundles)(historyDir))
+        history.push((await (0, import_diagnostics.verifyRuntimeEvidenceBundle)(directory)).artifact);
+    const runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "") + "-" + (0, import_node_crypto2.randomUUID)();
+    const runDir = import_node_path2.default.join(outputRoot, artifactId, runId);
+    await import_promises2.default.mkdir(runDir, { recursive: true });
+    const calibration = buildExecutionCalibrationReport({
+      runtimeArtifact: runtimeEvidence.artifact,
+      replayEvidenceArtifact: feedback.replayEvidence
+    });
+    await import_promises2.default.writeFile(
+      import_node_path2.default.join(runDir, "execution-calibration.json"),
+      JSON.stringify(calibration, null, 2)
+    );
+    const inputs = {
+      runtimeArtifact: runtimeEvidence.artifact,
+      replayEvidenceArtifact: feedback.replayEvidence,
+      calibrationArtifact: calibration,
+      historyRuntimeArtifacts: history
+    };
+    for (const strategy of [...strategies.map((s) => s.strategyName), null]) {
+      const scorecard = buildRuntimeScorecard({ ...inputs, strategy });
+      const base = import_node_path2.default.join(
+        runDir,
+        strategy ? `runtime-scorecard-${strategy}` : "runtime-scorecard"
+      );
+      await import_promises2.default.writeFile(base + ".json", JSON.stringify(scorecard, null, 2));
+      await import_promises2.default.writeFile(
+        base + ".md",
+        formatRuntimeScorecardMarkdown(scorecard)
+      );
+    }
+    await (0, import_diagnostics.verifyRuntimeFeedbackReplaySource)({
+      bundleDir: replayDir,
+      runtimeEvidenceBundleDir: runtimeDir
+    });
+    const scorecardPath = import_node_path2.default.join(runDir, "runtime-scorecard.json");
+    await markRuntimeEvidenceBundleProcessed({
+      evidenceRoot,
+      deploymentId,
+      bundleDir: runtimeDir,
+      scorecardPath,
+      runtimeFeedback: {
+        artifactId: feedback.manifest.artifactId,
+        replayEvidenceSha256: feedback.manifest.payloads.replayEvidence.sha256
+      }
+    });
+    return { processed: true, receiptPath: receiptPath2, scorecardPath };
+  } finally {
+    await import_promises2.default.rmdir(lock);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processRuntimeFeedbackPair
+});