@tradejs/cli 2.0.15 → 2.0.17

package/dist/scripts/runtimeScorecard.js

@@ -0,0 +1,731 @@
+"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 __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/scripts/runtimeScorecard.ts
+var runtimeScorecard_exports = {};
+__export(runtimeScorecard_exports, {
+  main: () => main,
+  runtimeScorecard: () => runtimeScorecard
+});
+module.exports = __toCommonJS(runtimeScorecard_exports);
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
+var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
+var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+var assertFiniteTimestamp = (value, label) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid runtime evidence ${label}`);
+  }
+  return value;
+};
+var parseManifest = (value) => {
+  const manifest = asRecord(value);
+  const window = asRecord(manifest?.window);
+  const payload = asRecord(manifest?.payload);
+  const counts = asRecord(manifest?.counts);
+  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence" || typeof manifest.artifactId !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.userName !== "string" || typeof manifest.createdAt !== "number" || payload?.file !== RUNTIME_EVIDENCE_PAYLOAD_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Array.isArray(manifest.lineageKeys)) {
+    throw new Error("Invalid runtime evidence manifest");
+  }
+  return {
+    schemaVersion: 1,
+    artifactId: manifest.artifactId,
+    reportType: "runtime-evidence",
+    deploymentId: manifest.deploymentId,
+    userName: manifest.userName,
+    createdAt: manifest.createdAt,
+    window: {
+      startTime: assertFiniteTimestamp(window?.startTime, "window.startTime"),
+      endTime: assertFiniteTimestamp(window?.endTime, "window.endTime")
+    },
+    payload: {
+      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
+      sha256: payload.sha256,
+      bytes: payload.bytes
+    },
+    counts: Object.fromEntries(
+      Object.entries(counts ?? {}).filter(
+        (entry) => typeof entry[1] === "number" && Number.isFinite(entry[1])
+      )
+    ),
+    lineageKeys: manifest.lineageKeys.filter(
+      (value2) => typeof value2 === "string" && value2.length > 0
+    )
+  };
+};
+var verifyRuntimeEvidenceBundle = async (bundleDir) => {
+  const manifestPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_MANIFEST_FILE);
+  const payloadPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_PAYLOAD_FILE);
+  const completePath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_COMPLETE_FILE);
+  const [manifestText, payload, completeText] = await Promise.all([
+    import_promises.default.readFile(manifestPath, "utf8"),
+    import_promises.default.readFile(payloadPath),
+    import_promises.default.readFile(completePath, "utf8")
+  ]);
+  const manifest = parseManifest(JSON.parse(manifestText));
+  if (completeText.trim() !== manifest.artifactId) {
+    throw new Error(`Invalid completion marker in ${bundleDir}`);
+  }
+  if (payload.byteLength !== manifest.payload.bytes) {
+    throw new Error(`Runtime evidence size mismatch in ${bundleDir}`);
+  }
+  if (sha256(payload) !== manifest.payload.sha256) {
+    throw new Error(`Runtime evidence checksum mismatch in ${bundleDir}`);
+  }
+  const artifact = asRecord(JSON.parse(payload.toString("utf8")));
+  const artifactWindow = asRecord(artifact?.window);
+  if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
+    throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
+  }
+  return {
+    bundleDir,
+    manifestPath,
+    payloadPath,
+    manifest,
+    artifact
+  };
+};
+var discoverRuntimeEvidenceBundles = async (rootDir) => {
+  const bundles = [];
+  const visit = async (directory, depth) => {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = await import_promises.default.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const names = new Set(entries.map((entry) => entry.name));
+    if (names.has(RUNTIME_EVIDENCE_MANIFEST_FILE) && names.has(RUNTIME_EVIDENCE_PAYLOAD_FILE) && names.has(RUNTIME_EVIDENCE_COMPLETE_FILE)) {
+      bundles.push(directory);
+      return;
+    }
+    await Promise.all(
+      entries.filter(
+        (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+      ).map((entry) => visit(import_node_path.default.join(directory, entry.name), depth + 1))
+    );
+  };
+  await visit(rootDir, 0);
+  return bundles.sort();
+};
+
+// src/lib/runtimeEvidenceSync.ts
+var import_node_child_process = require("child_process");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_util = require("util");
+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_path2.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
+var markRuntimeEvidenceBundleProcessed = async ({
+  evidenceRoot,
+  deploymentId,
+  bundleDir,
+  scorecardPath
+}) => {
+  const safeDeploymentId = safeSegment(deploymentId, "production");
+  const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+  if (verified.manifest.deploymentId !== safeDeploymentId) {
+    throw new Error(
+      `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
+    );
+  }
+  const receiptsRoot = import_node_path2.default.join(evidenceRoot, "receipts", safeDeploymentId);
+  const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
+  const temporaryPath = `${finalPath}.tmp-${process.pid}`;
+  const receipt = {
+    schemaVersion: 1,
+    artifactId: verified.manifest.artifactId,
+    payloadSha256: verified.manifest.payload.sha256,
+    processedAt: Date.now(),
+    scorecardPath: scorecardPath ?? null
+  };
+  await import_promises2.default.mkdir(receiptsRoot, { recursive: true });
+  await import_promises2.default.writeFile(
+    temporaryPath,
+    `${JSON.stringify(receipt, null, 2)}
+`,
+    "utf8"
+  );
+  await import_promises2.default.rename(temporaryPath, finalPath);
+  return finalPath;
+};
+
+// src/lib/runtimeScorecard.ts
+var asRecord2 = (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 round = (value, decimals = 6) => Number(value.toFixed(decimals));
+var unwrapRows = (value, key) => asArray(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"),
+    statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord2).filter((item) => item != null)
+  };
+};
+var countBy = (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 buildDistributions = ({
+  evaluations,
+  signals
+}) => {
+  const candidates = evaluations.filter(
+    (evaluation) => evaluation.status === "signal"
+  );
+  return {
+    candidatesByStrategy: countBy(
+      candidates,
+      (evaluation) => finiteString(evaluation.strategy)
+    ),
+    orderStatus: countBy(signals, (signal) => finiteString(signal.orderStatus)),
+    skipReasons: countBy(
+      signals,
+      (signal) => finiteString(signal.orderSkipReason)
+    ),
+    aiQuality: countBy(candidates, (evaluation) => {
+      const quality = finiteNumber(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 statsCount = (buckets, field) => sum(buckets.map((bucket) => finiteNumber(asRecord2(bucket.stats)?.[field])));
+var tradeTimestamp = (trade) => finiteNumber(trade.exitTimestamp) ?? finiteNumber(trade.lastSyncedAt) ?? finiteNumber(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 = finiteString(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 += finiteNumber(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 = finiteNumber(trade.exitTimestamp);
+    return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < anchorTime;
+  });
+  const realizedPnl = sum(closed.map((trade) => finiteNumber(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 getCalibrationSummary = (artifact) => {
+  const root = asRecord2(artifact) ?? {};
+  return asRecord2(asRecord2(root.summary)?.all) ?? null;
+};
+var buildRuntimeScorecard = ({
+  runtimeArtifact,
+  replayEvidenceArtifact,
+  calibrationArtifact,
+  historyRuntimeArtifacts = [],
+  thresholds = {
+    minimumParityRatio: 0.95,
+    maximumSlippageResidualBps: 3,
+    minimumClosedTrades: 20,
+    minimumExpectancy: 0
+  },
+  generatedAt = Date.now()
+}) => {
+  const rows = extractRuntimeRows(runtimeArtifact);
+  const window = runtimeWindow(runtimeArtifact);
+  const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
+  const endTime = finiteNumber(window.endTime) ?? generatedAt;
+  const evaluationsFromStats = statsCount(rows.statsBuckets, "evaluated");
+  const candidatesFromStats = statsCount(rows.statsBuckets, "signals");
+  const signalEvaluations = rows.evaluations.filter(
+    (evaluation) => evaluation.status === "signal"
+  );
+  const gateDecisions = signalEvaluations.map((evaluation) => ({
+    evaluation,
+    decision: finiteString(asRecord2(evaluation.aiAnalysis)?.gateDecision)
+  })).filter(
+    ({ decision }) => decision === "approved" || decision === "rejected"
+  );
+  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 = finiteNumber(trade.exitTimestamp);
+    return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
+  });
+  const replayComparison = getReplayComparison(replayEvidenceArtifact);
+  const replayCounts = asRecord2(replayComparison?.counts);
+  const matched = finiteNumber(replayCounts?.matched) ?? 0;
+  const backtestOnly = finiteNumber(replayCounts?.backtestOnly) ?? 0;
+  const runtimeOnly = finiteNumber(replayCounts?.runtimeOnly) ?? 0;
+  const comparisonTotal = matched + backtestOnly + runtimeOnly;
+  const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
+  const lineage = asRecord2(replayComparison?.lineage);
+  const lineageReason = finiteString(lineage?.reason);
+  const calibration = getCalibrationSummary(calibrationArtifact);
+  const actualSlippageBps = finiteNumber(
+    asRecord2(calibration?.signalToFillAdverseBps)?.avg
+  );
+  const residualVsModelBps = finiteNumber(
+    asRecord2(calibration?.residualVsCurrentModelBps)?.avg
+  );
+  const historyTrades = dedupeTrades([
+    ...historyRuntimeArtifacts,
+    runtimeArtifact
+  ]);
+  const currentDistributions = buildDistributions(rows);
+  const previousArtifact = historyRuntimeArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
+    const candidateEndTime = finiteNumber(candidateWindow.endTime);
+    return candidateEndTime != null && candidateEndTime <= startTime;
+  }).sort(
+    (left, right) => (finiteNumber(right.window.endTime) ?? 0) - (finiteNumber(left.window.endTime) ?? 0)
+  )[0];
+  const previousDistributions = previousArtifact ? buildDistributions(extractRuntimeRows(previousArtifact.artifact)) : null;
+  const rolling = [7, 30, 90].map(
+    (days) => buildRollingPerformance({
+      trades: [...historyTrades],
+      anchorTime: endTime,
+      days
+    })
+  );
+  const sevenDay = rolling[0];
+  const reactions = [];
+  if (lineageReason) {
+    reactions.push({
+      code: "LINEAGE_NOT_COMPARABLE",
+      severity: "blocking",
+      message: lineageReason
+    });
+  }
+  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: `Execution residual ${round(residualVsModelBps, 2)} bps exceeds ${thresholds.maximumSlippageResidualBps} bps.`
+    });
+  }
+  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 },
+    promotionStatus,
+    thresholds,
+    funnel: {
+      evaluations: evaluationsFromStats > 0 ? evaluationsFromStats : rows.evaluations.length,
+      coreCandidates: candidatesFromStats > 0 ? candidatesFromStats : 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
+      },
+      allocator: {
+        available: allocatorDecisions.length > 0,
+        approved: allocatorDecisions.filter(
+          (decision) => decision.decision === "approved"
+        ).length,
+        rejected: allocatorDecisions.filter(
+          (decision) => decision.decision === "rejected"
+        ).length
+      },
+      risk: {
+        available: riskDecisions.length > 0,
+        approved: riskDecisions.filter(
+          (decision) => decision.decision === "approved"
+        ).length,
+        rejected: riskDecisions.filter(
+          (decision) => decision.decision === "rejected"
+        ).length
+      },
+      orderAttempts: orderAttempts.length,
+      orderFailures: orderAttempts.filter(
+        (signal) => signal.orderStatus === "failed"
+      ).length,
+      balanceRejects: rows.signals.filter(
+        (signal) => /BALANCE|MARGIN/i.test(
+          `${finiteString(signal.orderSkipReason) ?? ""} ${finiteString(signal.orderFailureReason) ?? ""}`
+        )
+      ).length,
+      fills: rows.trades.length,
+      closedTrades: currentClosedTrades.length
+    },
+    realized: {
+      pnl: sum(
+        currentClosedTrades.map((trade) => finiteNumber(trade.closedPnl))
+      ),
+      fees: sum(
+        currentClosedTrades.map((trade) => finiteNumber(trade.totalFee))
+      ),
+      funding: sum(
+        currentClosedTrades.map((trade) => finiteNumber(trade.fundingFee))
+      )
+    },
+    parity: {
+      available: comparisonTotal > 0,
+      matched,
+      backtestOnly,
+      runtimeOnly,
+      ratio: parityRatio == null ? null : round(parityRatio),
+      lineageReason
+    },
+    execution: {
+      available: calibration != null,
+      actualSignalToFillSlippageBps: actualSlippageBps,
+      residualVsCurrentModelBps: residualVsModelBps
+    },
+    rolling,
+    distributions: currentDistributions,
+    distributionChanges: {
+      available: previousDistributions != null,
+      baselineWindow: previousArtifact ? {
+        startTime: finiteNumber(previousArtifact.window.startTime),
+        endTime: finiteNumber(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}
+- Allocator approvals/rejects: ${scorecard.funnel.allocator.available ? `${scorecard.funnel.allocator.approved}/${scorecard.funnel.allocator.rejected}` : "unavailable"}
+- Risk approvals/rejects: ${scorecard.funnel.risk.available ? `${scorecard.funnel.risk.approved}/${scorecard.funnel.risk.rejected}` : "unavailable"}
+- 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}
+- Actual signal-to-fill slippage: ${scorecard.execution.actualSignalToFillSlippageBps ?? "n/a"} bps
+- Residual vs current model: ${scorecard.execution.residualVsCurrentModelBps ?? "n/a"} bps
+
+## 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/scripts/runtimeScorecard.ts
+import_args.default.option("runtimeEvidence", "Verified runtime evidence JSON");
+import_args.default.option("replayEvidence", "Replay runtime evidence JSON");
+import_args.default.option("calibration", "Execution calibration JSON");
+import_args.default.option("historyDir", "Directory containing verified evidence bundles");
+import_args.default.option(
+  "evidenceDir",
+  "Local evidence storage root used for processing receipts",
+  process.env.RUNTIME_EVIDENCE_LOCAL_DIR || "data/runtime-evidence"
+);
+import_args.default.option(
+  "deployment",
+  "Deployment id used for processing receipts",
+  process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
+);
+import_args.default.option("markProcessed", "Write a processing receipt on success", false);
+import_args.default.option(
+  ["P", "minimumParityRatio"],
+  "Minimum acceptable replay parity",
+  0.95
+);
+import_args.default.option(
+  ["S", "maximumSlippageResidualBps"],
+  "Maximum acceptable execution residual in bps",
+  3
+);
+import_args.default.option(
+  ["T", "minimumClosedTrades"],
+  "Minimum 7d closed trades for expectancy reactions",
+  20
+);
+import_args.default.option(["X", "minimumExpectancy"], "Minimum acceptable 7d expectancy", 0);
+import_args.default.option(["o", "out"], "Output JSON path", "output/runtime-scorecard.json");
+var flags = import_args.default.parse(process.argv);
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var resolveOptionalPath = (value) => {
+  const raw = String(value ?? "").trim();
+  return raw ? import_node_path3.default.resolve(projectRoot, raw) : null;
+};
+var readJson = async (filePath) => filePath ? JSON.parse(await import_promises3.default.readFile(filePath, "utf8")) : void 0;
+var loadHistoryArtifacts = async (historyDir) => {
+  if (!historyDir) return [];
+  const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
+  const bundles = [];
+  for (const bundleDir of bundleDirs) {
+    bundles.push(await verifyRuntimeEvidenceBundle(bundleDir));
+  }
+  return bundles.map((bundle) => bundle.artifact);
+};
+var runtimeScorecard = async () => {
+  const runtimeEvidencePath = resolveOptionalPath(flags.runtimeEvidence);
+  if (!runtimeEvidencePath) {
+    throw new Error("Provide --runtimeEvidence for the runtime scorecard.");
+  }
+  const replayEvidencePath = resolveOptionalPath(flags.replayEvidence);
+  const calibrationPath = resolveOptionalPath(flags.calibration);
+  const historyDir = resolveOptionalPath(flags.historyDir);
+  const [
+    runtimeArtifact,
+    replayEvidenceArtifact,
+    calibrationArtifact,
+    history
+  ] = await Promise.all([
+    readJson(runtimeEvidencePath),
+    readJson(replayEvidencePath),
+    readJson(calibrationPath),
+    loadHistoryArtifacts(historyDir)
+  ]);
+  const scorecard = buildRuntimeScorecard({
+    runtimeArtifact,
+    replayEvidenceArtifact,
+    calibrationArtifact,
+    historyRuntimeArtifacts: history,
+    thresholds: {
+      minimumParityRatio: Number(flags.minimumParityRatio),
+      maximumSlippageResidualBps: Number(flags.maximumSlippageResidualBps),
+      minimumClosedTrades: Number(flags.minimumClosedTrades),
+      minimumExpectancy: Number(flags.minimumExpectancy)
+    }
+  });
+  const outPath = import_node_path3.default.resolve(projectRoot, String(flags.out));
+  const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
+  await Promise.all([
+    import_promises3.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+`, "utf8"),
+    import_promises3.default.writeFile(
+      markdownPath,
+      formatRuntimeScorecardMarkdown(scorecard),
+      "utf8"
+    )
+  ]);
+  let receiptPath2 = null;
+  if (flags.markProcessed) {
+    receiptPath2 = await markRuntimeEvidenceBundleProcessed({
+      evidenceRoot: import_node_path3.default.resolve(projectRoot, String(flags.evidenceDir)),
+      deploymentId: String(flags.deployment),
+      bundleDir: import_node_path3.default.dirname(runtimeEvidencePath),
+      scorecardPath: outPath
+    });
+  }
+  console.log(import_chalk.default.green(`Wrote ${outPath}`));
+  console.log(import_chalk.default.green(`Wrote ${markdownPath}`));
+  console.log(
+    JSON.stringify(
+      {
+        promotionStatus: scorecard.promotionStatus,
+        funnel: scorecard.funnel,
+        parity: scorecard.parity,
+        execution: scorecard.execution,
+        rolling: scorecard.rolling,
+        reactions: scorecard.reactions,
+        receiptPath: receiptPath2
+      },
+      null,
+      2
+    )
+  );
+};
+var main = runtimeScorecard;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  runtimeScorecard
+});