@tradejs/cli 3.1.29-beta.262 → 3.1.29-beta.264

package/dist/scripts/runtimeScorecard.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   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-
@@ -34,453 +35,37 @@ __export(runtimeScorecard_exports, {
   runtimeScorecard: () => runtimeScorecard
 });
 module.exports = __toCommonJS(runtimeScorecard_exports);
-var import_promises6 = __toESM(require("fs/promises"));
-var import_node_crypto6 = require("crypto");
-var import_node_path6 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_crypto3 = require("crypto");
+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"));
-
-// src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
-var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
-  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
-);
-var INTERVALS = /* @__PURE__ */ new Set([
-  "1",
-  "3",
-  "5",
-  "15",
-  "30",
-  "60",
-  "120",
-  "240",
-  "360",
-  "720",
-  "D",
-  "W",
-  "M"
-]);
-var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
-var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
-var samePackageVersions = (left, right) => {
-  if (!left || !right) return false;
-  const leftEntries = Object.entries(left).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  const rightEntries = Object.entries(right).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
-};
-var runtimeLineageMatchesStrategySnapshot = ({
-  lineage,
-  deployment,
-  strategy
-}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
-  lineage.strategyDependencyVersions,
-  strategy.strategyDependencyVersions
-);
-var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
-  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
-    throw new Error(
-      "Runtime evidence deployment snapshot is missing or invalid"
-    );
-  }
-  const strategies = value.strategies.map((candidate) => {
-    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
-      throw new Error(
-        "Runtime evidence deployment strategy snapshot is invalid"
-      );
-    }
-    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
-      throw new Error(
-        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
-      );
-    }
-    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
-      throw new Error(
-        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
-      );
-    }
-    return candidate;
-  });
-  const identities = /* @__PURE__ */ new Set();
-  for (const strategy of strategies) {
-    if (identities.has(strategy.strategyName)) {
-      throw new Error(
-        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
-      );
-    }
-    identities.add(strategy.strategyName);
-  }
-  return {
-    ...value,
-    strategies
-  };
-};
-var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
-var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
-  const record = isRecord(candidate) ? candidate : null;
-  const nested = record && isRecord(record[field]) ? record[field] : null;
-  return nested ?? record;
-}).filter((record) => record != null);
-var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
-  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
-    throw new Error("Invalid runtime evidence artifact");
-  }
-  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
-    artifact.deployment
-  );
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-  if (activeStrategies.length === 0) {
-    throw new Error("Runtime evidence deployment has no enabled strategies");
-  }
-  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
-  if (!runtime) {
-    throw new Error("Runtime evidence payload is missing");
-  }
-  if ("strategyConfigs" in runtime) {
-    throw new Error(
-      "Runtime evidence payload contains removed strategyConfigs data"
-    );
-  }
-  if ("evaluationStatsBuckets" in runtime) {
-    throw new Error(
-      "Runtime evidence payload contains removed lineage-less evaluationStatsBuckets data"
-    );
-  }
-  const rowFields = [
-    "trades",
-    "signals",
-    "evaluations",
-    "lineageScopes"
-  ];
-  for (const field of rowFields) {
-    if (!Array.isArray(runtime[field])) {
-      throw new Error(`Runtime evidence payload ${field} must be an array`);
-    }
-  }
-  const snapshots = new Map(
-    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-  );
-  const assertRows = (label, rows, lineageField) => {
-    for (const row of rows) {
-      const strategyName = String(row.strategy ?? "").trim();
-      const strategy = snapshots.get(strategyName);
-      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
-        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
-        deployment,
-        strategy
-      })) {
-        throw new Error(
-          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
-        );
-      }
-    }
-  };
-  assertRows(
-    "trade",
-    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "signal",
-    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "evaluation",
-    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "lineage scope",
-    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
-    "lineage"
-  );
-  return deployment;
-};
-
-// src/lib/runtimeEvidenceArtifacts.ts
-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}`);
-  }
-  const deployment = assertCurrentRuntimeEvidenceArtifact(artifact);
-  if (deployment.id !== manifest.deploymentId) {
-    throw new Error(`Runtime evidence deployment 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();
-};
+var runtimeEvidenceArtifacts_exports = {};
+__reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
 
 // src/lib/runtimeFeedbackArtifacts.ts
-var import_node_crypto3 = require("crypto");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
-
-// src/lib/runtimeEvidenceProducer.ts
-var import_node_crypto2 = require("crypto");
-var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
-var isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var parseRuntimeEvidenceProducer = (value) => {
-  const producer = isRecord2(value) ? value : null;
-  const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
-  if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
-    throw new Error("Runtime evidence producer image identity is invalid");
-  }
-  return producer;
-};
-
-// src/lib/runtimeFeedbackArtifacts.ts
-var RUNTIME_FEEDBACK_MANIFEST_FILE = "manifest.json";
-var RUNTIME_FEEDBACK_REPLAY_FILE = "replay-runtime-evidence.json";
-var RUNTIME_FEEDBACK_LOG_FILE = "replay.log";
-var RUNTIME_FEEDBACK_COMPLETE_FILE = ".complete";
-var isRecord3 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var sha2562 = (value) => (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
-var parsePayload = (value, expectedFile) => {
-  const payload = isRecord3(value) ? value : null;
-  if (payload?.file !== expectedFile || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Number.isFinite(payload.bytes) || payload.bytes < 0) {
-    throw new Error(`Invalid runtime feedback payload: ${expectedFile}`);
-  }
-  return payload;
-};
-var parseManifest2 = (value) => {
-  const manifest = isRecord3(value) ? value : null;
-  const window = isRecord3(manifest?.window) ? manifest.window : null;
-  const runtimeEvidence = isRecord3(manifest?.runtimeEvidence) ? manifest.runtimeEvidence : null;
-  const safety = isRecord3(manifest?.safety) ? manifest.safety : null;
-  const payloads = isRecord3(manifest?.payloads) ? manifest.payloads : null;
-  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-feedback-replay" || typeof manifest.artifactId !== "string" || !manifest.artifactId.trim() || typeof manifest.runId !== "string" || !manifest.runId.trim() || typeof manifest.deploymentId !== "string" || !manifest.deploymentId.trim() || typeof manifest.deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(manifest.deploymentCompositionId) || typeof manifest.userName !== "string" || !manifest.userName.trim() || typeof manifest.createdAt !== "number" || typeof window?.startTime !== "number" || typeof window.endTime !== "number" || typeof runtimeEvidence?.artifactId !== "string" || typeof runtimeEvidence.payloadSha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimeEvidence.payloadSha256) || !Array.isArray(manifest.activeStrategies) || manifest.activeStrategies.length === 0 || !manifest.activeStrategies.every(
-    (strategy) => typeof strategy === "string" && strategy.trim()
-  ) || typeof manifest.cycleCount !== "number" || !Number.isFinite(manifest.cycleCount) || manifest.cycleCount <= 0 || safety?.cacheOnly !== true || safety.externalOrderPlacement !== false || safety.redis !== "isolated" || safety.timescale !== "read_only") {
-    throw new Error("Invalid runtime feedback replay manifest");
-  }
-  const replayEvidence = parsePayload(
-    payloads?.replayEvidence,
-    RUNTIME_FEEDBACK_REPLAY_FILE
-  );
-  const log = parsePayload(payloads?.log, RUNTIME_FEEDBACK_LOG_FILE);
-  return {
-    ...manifest,
-    producer: parseRuntimeEvidenceProducer(manifest.producer),
-    payloads: {
-      replayEvidence: {
-        ...replayEvidence,
-        file: RUNTIME_FEEDBACK_REPLAY_FILE
-      },
-      log: { ...log, file: RUNTIME_FEEDBACK_LOG_FILE }
-    }
-  };
-};
-var assertReplayMatchesRuntimeEvidence = ({
-  replayEvidence,
-  runtimeEvidence
-}) => {
-  if (replayEvidence.reportType !== "replay-runtime-evidence") {
-    throw new Error("Runtime feedback replay payload has the wrong reportType");
-  }
-  const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
-  if (replayWindow?.startTime !== runtimeEvidence.manifest.window.startTime || replayWindow.endTime !== runtimeEvidence.manifest.window.endTime) {
-    throw new Error("Runtime feedback replay window does not match evidence");
-  }
-  const runtimeDeployment = parseRuntimeEvidenceDeploymentSnapshot(
-    runtimeEvidence.artifact.deployment
-  );
-  const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
-    replayEvidence.deployment
-  );
-  if (replayDeployment.id !== runtimeDeployment.id || replayDeployment.deploymentCompositionId !== runtimeDeployment.deploymentCompositionId) {
-    throw new Error(
-      "Runtime feedback replay deployment does not match evidence"
-    );
-  }
-};
-var verifyRuntimeFeedbackReplayBundle = async (bundleDir) => {
-  const manifestPath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_MANIFEST_FILE);
-  const replayEvidencePath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_REPLAY_FILE);
-  const logPath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_LOG_FILE);
-  const completePath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_COMPLETE_FILE);
-  const [manifestText, replayPayload, logPayload, completeText] = await Promise.all([
-    import_promises3.default.readFile(manifestPath, "utf8"),
-    import_promises3.default.readFile(replayEvidencePath),
-    import_promises3.default.readFile(logPath),
-    import_promises3.default.readFile(completePath, "utf8")
-  ]);
-  const manifest = parseManifest2(JSON.parse(manifestText));
-  if (completeText.trim() !== manifest.artifactId) {
-    throw new Error(`Invalid runtime feedback completion marker: ${bundleDir}`);
-  }
-  for (const [payload, descriptor] of [
-    [replayPayload, manifest.payloads.replayEvidence],
-    [logPayload, manifest.payloads.log]
-  ]) {
-    if (payload.byteLength !== descriptor.bytes) {
-      throw new Error(
-        `Runtime feedback payload size mismatch: ${descriptor.file}`
-      );
-    }
-    if (sha2562(payload) !== descriptor.sha256) {
-      throw new Error(
-        `Runtime feedback payload checksum mismatch: ${descriptor.file}`
-      );
-    }
-  }
-  const replayEvidence = JSON.parse(replayPayload.toString("utf8"));
-  if (replayEvidence.reportType !== "replay-runtime-evidence") {
-    throw new Error("Invalid runtime feedback replay evidence payload");
-  }
-  const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
-  const replay = isRecord3(replayEvidence.replay) ? replayEvidence.replay : null;
-  const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
-    replayEvidence.deployment
-  );
-  const replayStrategies = activeRuntimeEvidenceStrategies(replayDeployment).map(({ strategyName }) => strategyName).sort();
-  if (replayEvidence.userName !== manifest.userName || replayWindow?.startTime !== manifest.window.startTime || replayWindow.endTime !== manifest.window.endTime || replayDeployment.id !== manifest.deploymentId || replayDeployment.deploymentCompositionId !== manifest.deploymentCompositionId || Number(replay?.cycleCount) !== manifest.cycleCount || JSON.stringify(replayStrategies) !== JSON.stringify([...manifest.activeStrategies].sort())) {
-    throw new Error("Runtime feedback replay payload does not match manifest");
-  }
-  return {
-    bundleDir,
-    manifestPath,
-    replayEvidencePath,
-    logPath,
-    manifest,
-    replayEvidence
-  };
-};
-var verifyRuntimeFeedbackReplaySource = async ({
-  bundleDir,
-  runtimeEvidenceBundleDir
-}) => {
-  const [feedback, runtimeEvidence] = await Promise.all([
-    verifyRuntimeFeedbackReplayBundle(bundleDir),
-    verifyRuntimeEvidenceBundle(runtimeEvidenceBundleDir)
-  ]);
-  if (feedback.manifest.runtimeEvidence.artifactId !== runtimeEvidence.manifest.artifactId || feedback.manifest.runtimeEvidence.payloadSha256 !== runtimeEvidence.manifest.payload.sha256) {
-    throw new Error("Runtime feedback bundle references different evidence");
-  }
-  assertReplayMatchesRuntimeEvidence({
-    replayEvidence: feedback.replayEvidence,
-    runtimeEvidence
-  });
-  return { feedback, runtimeEvidence };
-};
+var runtimeFeedbackArtifacts_exports = {};
+__reExport(runtimeFeedbackArtifacts_exports, require("@tradejs/node/diagnostics"));
 
 // src/lib/runtimeEvidenceSync.ts
 var import_node_child_process = require("child_process");
-var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path4 = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
 var import_node_util = require("util");
+
+// src/lib/runtimeEvidenceDeployment.ts
+var runtimeEvidenceDeployment_exports = {};
+__reExport(runtimeEvidenceDeployment_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_path4.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
+var receiptPath = (receiptsRoot, artifactId) => import_node_path.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
 var markRuntimeEvidenceBundleProcessed = async ({
   evidenceRoot,
   deploymentId,
@@ -489,13 +74,13 @@ var markRuntimeEvidenceBundleProcessed = async ({
   runtimeFeedback
 }) => {
   const safeDeploymentId = safeSegment(deploymentId, "production");
-  const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+  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_path4.default.join(evidenceRoot, "receipts", safeDeploymentId);
+  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 = {
@@ -509,19 +94,19 @@ var markRuntimeEvidenceBundleProcessed = async ({
       replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
     } : {}
   };
-  await import_promises4.default.mkdir(receiptsRoot, { recursive: true });
-  await import_promises4.default.writeFile(
+  await import_promises.default.mkdir(receiptsRoot, { recursive: true });
+  await import_promises.default.writeFile(
     temporaryPath,
     `${JSON.stringify(receipt, null, 2)}
 `,
     "utf8"
   );
-  await import_promises4.default.rename(temporaryPath, finalPath);
+  await import_promises.default.rename(temporaryPath, finalPath);
   return finalPath;
 };
 
 // src/lib/runtimeLineage.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto = require("crypto");
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -533,7 +118,7 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+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,
@@ -544,12 +129,12 @@ var runtimeLineageKey = (lineage) => [
 ].join(":");
 
 // src/lib/runtimeScorecard.ts
-var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : 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 packageVersionMap = (value) => {
-  const record = asRecord2(value);
+  const record = asRecord(value);
   if (!record || Object.keys(record).length === 0) return null;
   const entries = Object.entries(record);
   if (entries.some(
@@ -562,14 +147,14 @@ var packageVersionMap = (value) => {
   );
 };
 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 unwrapRows = (value, key) => asArray(value).map((item) => asRecord(asRecord(item)?.[key]) ?? asRecord(item)).filter((item) => item != null);
 var runtimePayload = (artifact) => {
-  const root = asRecord2(artifact) ?? {};
-  return asRecord2(root.runtime) ?? root;
+  const root = asRecord(artifact) ?? {};
+  return asRecord(root.runtime) ?? root;
 };
 var runtimeWindow = (artifact) => {
-  const root = asRecord2(artifact) ?? {};
-  return asRecord2(root.window) ?? asRecord2(runtimePayload(artifact).window) ?? {};
+  const root = asRecord(artifact) ?? {};
+  return asRecord(root.window) ?? asRecord(runtimePayload(artifact).window) ?? {};
 };
 var extractRuntimeRows = (artifact) => {
   const runtime = runtimePayload(artifact);
@@ -585,7 +170,7 @@ var buildEmbeddedLineageScope = ({
   rows,
   strategy
 }) => {
-  const deployment = asRecord2(asRecord2(artifact)?.deployment);
+  const deployment = asRecord(asRecord(artifact)?.deployment);
   if (finiteNumber(deployment?.schemaVersion) !== 2) return null;
   const deploymentId = finiteString(deployment?.id);
   const accountId = finiteString(deployment?.accountId);
@@ -593,7 +178,7 @@ var buildEmbeddedLineageScope = ({
     deployment?.deploymentCompositionId
   );
   if (!deploymentId || !accountId || !deploymentCompositionId) return null;
-  const snapshots = asArray(deployment?.strategies).map(asRecord2).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+  const snapshots = asArray(deployment?.strategies).map(asRecord).filter((item) => item != null).filter((item) => item.enabled === true).filter(
     (item) => !strategy || finiteString(item.strategyName) === strategy
   );
   const targetSeeds = snapshots.map((snapshot) => {
@@ -635,10 +220,10 @@ var buildEmbeddedLineageScope = ({
   const targets = /* @__PURE__ */ new Map();
   for (const seed of targetSeeds) {
     const matchingRows = lineageRows.filter(
-      (row) => finiteString(row.strategy) === seed.strategyName && finiteString(row.deploymentId) === deploymentId && finiteString(row.accountId) === accountId && identityMatches(asRecord2(row.runtimeLineage), seed)
+      (row) => finiteString(row.strategy) === seed.strategyName && finiteString(row.deploymentId) === deploymentId && finiteString(row.accountId) === accountId && identityMatches(asRecord(row.runtimeLineage), seed)
     );
     const riskValues = new Set(
-      matchingRows.map((row) => finiteNumber(asRecord2(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
+      matchingRows.map((row) => finiteNumber(asRecord(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
     );
     targets.set(seed.strategyName, {
       ...seed,
@@ -650,7 +235,7 @@ var buildEmbeddedLineageScope = ({
   const belongs = (row) => {
     const strategyName = finiteString(row.strategy);
     const target = strategyName ? targets.get(strategyName) : null;
-    const lineage = asRecord2(row.runtimeLineage);
+    const lineage = asRecord(row.runtimeLineage);
     return Boolean(
       target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber(lineage?.maxLossValue) === target.maxLossValue
     );
@@ -707,7 +292,7 @@ var buildEmbeddedLineageScope = ({
   };
 };
 var runtimeDeploymentBinding = (artifact) => {
-  const deployment = asRecord2(asRecord2(artifact)?.deployment);
+  const deployment = asRecord(asRecord(artifact)?.deployment);
   return {
     deploymentId: finiteString(deployment?.id),
     accountId: finiteString(deployment?.accountId)
@@ -717,7 +302,7 @@ var belongsToRuntimeDeployment = (row, binding) => binding.deploymentId == null
 var belongsToStrategy = (row, strategy) => strategy == null || finiteString(row.strategy) === strategy;
 var filterArtifactByStrategy = (artifact, strategy) => {
   if (!strategy) return artifact;
-  const root = asRecord2(artifact) ?? {};
+  const root = asRecord(artifact) ?? {};
   const runtime = runtimePayload(artifact);
   return {
     ...root,
@@ -725,24 +310,24 @@ var filterArtifactByStrategy = (artifact, strategy) => {
       ...runtime,
       evaluations: asArray(runtime.evaluations).filter(
         (item) => belongsToStrategy(
-          asRecord2(asRecord2(item)?.evaluation) ?? asRecord2(item) ?? {},
+          asRecord(asRecord(item)?.evaluation) ?? asRecord(item) ?? {},
           strategy
         )
       ),
       signals: asArray(runtime.signals).filter(
         (item) => belongsToStrategy(
-          asRecord2(asRecord2(item)?.signal) ?? asRecord2(item) ?? {},
+          asRecord(asRecord(item)?.signal) ?? asRecord(item) ?? {},
           strategy
         )
       ),
       trades: asArray(runtime.trades).filter(
         (item) => belongsToStrategy(
-          asRecord2(asRecord2(item)?.trade) ?? asRecord2(item) ?? {},
+          asRecord(asRecord(item)?.trade) ?? asRecord(item) ?? {},
           strategy
         )
       ),
       lineageScopes: asArray(runtime.lineageScopes).filter(
-        (item) => belongsToStrategy(asRecord2(item) ?? {}, strategy)
+        (item) => belongsToStrategy(asRecord(item) ?? {}, strategy)
       )
     }
   };
@@ -759,7 +344,7 @@ var countBy = (items, getter) => {
   );
 };
 var resolveGateDecision = (evaluation) => {
-  const analysis = asRecord2(evaluation.aiAnalysis);
+  const analysis = asRecord(evaluation.aiAnalysis);
   const explicit = finiteString(analysis?.gateDecision);
   if (explicit === "approved" || explicit === "rejected") {
     return { decision: explicit, source: "gate_decision" };
@@ -790,7 +375,7 @@ var buildDistributions = ({
       (signal) => finiteString(signal.orderSkipReason)
     ),
     aiQuality: countBy(candidates, (evaluation) => {
-      const quality = finiteNumber(asRecord2(evaluation.aiAnalysis)?.quality);
+      const quality = finiteNumber(asRecord(evaluation.aiAnalysis)?.quality);
       return quality == null ? null : String(quality);
     })
   };
@@ -875,13 +460,13 @@ var buildRollingPerformance = ({
   };
 };
 var getReplayComparison = (artifact) => {
-  const root = asRecord2(artifact) ?? {};
-  return asRecord2(asRecord2(root.replay)?.runtimeComparison) ?? null;
+  const root = asRecord(artifact) ?? {};
+  return asRecord(asRecord(root.replay)?.runtimeComparison) ?? null;
 };
 var replayCountsForStrategy = (replayComparison, strategy) => {
   if (strategy) {
-    const byStrategy = asRecord2(replayComparison?.byStrategy);
-    const strategyCounts = asRecord2(byStrategy?.[strategy]);
+    const byStrategy = asRecord(replayComparison?.byStrategy);
+    const strategyCounts = asRecord(byStrategy?.[strategy]);
     if (strategyCounts) {
       return {
         matched: finiteNumber(strategyCounts.matched) ?? 0,
@@ -890,7 +475,7 @@ var replayCountsForStrategy = (replayComparison, strategy) => {
       };
     }
   }
-  const counts = asRecord2(replayComparison?.counts);
+  const counts = asRecord(replayComparison?.counts);
   return {
     matched: finiteNumber(counts?.matched) ?? 0,
     backtestOnly: finiteNumber(counts?.backtestOnly) ?? 0,
@@ -898,7 +483,7 @@ var replayCountsForStrategy = (replayComparison, strategy) => {
   };
 };
 var getProspectiveSummary = (artifact) => {
-  const root = asRecord2(artifact);
+  const root = asRecord(artifact);
   if (!root || root.reportType !== "strategy-prospective-evidence") return null;
   return {
     rawCoreExpectancy: finiteNumber(root.rawCoreExpectancy),
@@ -922,9 +507,9 @@ var buildRuntimeScorecard = ({
   strategy = null,
   llmComparatorPolicy = "ai_approved_only"
 }) => {
-  assertCurrentRuntimeEvidenceArtifact(runtimeArtifact);
+  (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(runtimeArtifact);
   for (const artifact of historyRuntimeArtifacts) {
-    assertCurrentRuntimeEvidenceArtifact(artifact);
+    (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(artifact);
   }
   const scopedRuntimeArtifact = filterArtifactByStrategy(
     runtimeArtifact,
@@ -959,7 +544,7 @@ var buildRuntimeScorecard = ({
     (evaluation) => resolveGateDecision(evaluation)?.decision === "approved"
   ) : signalEvaluations;
   const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
-    const analysis = asRecord2(evaluation.aiAnalysis);
+    const analysis = asRecord(evaluation.aiAnalysis);
     const gateDecision = resolveGateDecision(evaluation)?.decision ?? null;
     const llmDecision = finiteString(analysis?.llmDecision);
     if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
@@ -969,8 +554,8 @@ var buildRuntimeScorecard = ({
   }).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 allocatorDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.allocatorDecision)).filter((item) => item != null);
+  const riskDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.riskDecision)).filter((item) => item != null);
   const orderAttempts = rows.signals.filter(
     (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed"
   );
@@ -985,10 +570,10 @@ var buildRuntimeScorecard = ({
   const runtimeOnly = replayCounts.runtimeOnly;
   const comparisonTotal = matched + backtestOnly + runtimeOnly;
   const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
-  const lineage = asRecord2(replayComparison?.lineage);
+  const lineage = asRecord(replayComparison?.lineage);
   const lineageReason = finiteString(lineage?.reason);
-  const calibrationRoot = asRecord2(calibrationArtifact) ?? {};
-  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord2).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
+  const calibrationRoot = asRecord(calibrationArtifact) ?? {};
+  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
   const averageSampleMetric = (field) => {
     const values = calibrationSamples.map((sample) => finiteNumber(sample[field])).filter((value) => value != null);
     return values.length ? round(sum(values) / values.length) : null;
@@ -1331,9 +916,9 @@ ${reactions}
 };
 
 // src/lib/strategyRelease.ts
-var import_node_crypto5 = require("crypto");
-var import_promises5 = __toESM(require("fs/promises"));
-var import_node_path5 = __toESM(require("path"));
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
 var import_types2 = require("@tradejs/types");
 var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
@@ -1807,10 +1392,10 @@ var createStrategyReleaseManifest = (input) => {
     strategy: input.strategy,
     createdAt: input.createdAt,
     compositionId,
-    evidence: input.evidence.map(({ kind, artifactId, sha256: sha2563 }) => ({
+    evidence: input.evidence.map(({ kind, artifactId, sha256 }) => ({
       kind,
       artifactId,
-      sha256: sha2563
+      sha256
     })),
     verdict
   };
@@ -1834,7 +1419,7 @@ var createStrategyReleaseManifest = (input) => {
   };
 };
 var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises5.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises2.default.readFile(valueOrPath, "utf8")) : valueOrPath;
   const envelope = value;
   assert(
     envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -1885,19 +1470,19 @@ var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
   return envelope;
 };
 var verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises5.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises2.default.readFile(valueOrPath, "utf8")) : valueOrPath;
   return (0, import_strategyReleaseEvidence.verifyStrategyEvidenceMarkerEnvelope)(value);
 };
 var writeJsonAtomic = async (filePath, value) => {
   const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await import_promises5.default.mkdir(import_node_path5.default.dirname(filePath), { recursive: true });
-  await import_promises5.default.writeFile(
+  await import_promises2.default.mkdir(import_node_path2.default.dirname(filePath), { recursive: true });
+  await import_promises2.default.writeFile(
     temporaryPath,
     `${canonicalStrategyReleaseJson(value)}
 `,
     "utf8"
   );
-  await import_promises5.default.rename(temporaryPath, filePath);
+  await import_promises2.default.rename(temporaryPath, filePath);
 };
 var publishStrategyLiveDiagnosis = async ({
   rootDir,
@@ -1963,13 +1548,13 @@ var publishStrategyLiveDiagnosis = async ({
     markers,
     sourceArtifacts
   });
-  const diagnosisPath = import_node_path5.default.join(
+  const diagnosisPath = import_node_path2.default.join(
     rootDir,
     "diagnoses",
     safeSegment2(diagnosis.strategy, "strategy"),
     `${diagnosisId}.json`
   );
-  const markerPath = import_node_path5.default.join(
+  const markerPath = import_node_path2.default.join(
     rootDir,
     "markers",
     safeSegment2(diagnosis.strategy, "strategy"),
@@ -2046,21 +1631,21 @@ 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_path6.default.resolve(projectRoot, raw) : null;
+  return raw ? import_node_path3.default.resolve(projectRoot, raw) : null;
 };
-var readJson = async (filePath) => filePath ? JSON.parse(await import_promises6.default.readFile(filePath, "utf8")) : void 0;
+var readJson = async (filePath) => filePath ? JSON.parse(await import_promises3.default.readFile(filePath, "utf8")) : void 0;
 var assertReportType = (artifact, expected, label) => {
   if (artifact != null && (!artifact || typeof artifact !== "object" || Array.isArray(artifact) || artifact.reportType !== expected)) {
     throw new Error(`${label} must be a ${expected} artifact`);
   }
 };
-var sha256File = async (filePath) => (0, import_node_crypto6.createHash)("sha256").update(await import_promises6.default.readFile(filePath)).digest("hex");
+var sha256File = async (filePath) => (0, import_node_crypto3.createHash)("sha256").update(await import_promises3.default.readFile(filePath)).digest("hex");
 var loadHistoryArtifacts = async (historyDir) => {
   if (!historyDir) return [];
-  const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
+  const bundleDirs = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(historyDir);
   const bundles = [];
   for (const bundleDir of bundleDirs) {
-    bundles.push(await verifyRuntimeEvidenceBundle(bundleDir));
+    bundles.push(await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir));
   }
   return bundles.map((bundle) => bundle.artifact);
 };
@@ -2125,13 +1710,13 @@ var runtimeScorecard = async () => {
     strategy: scorecardStrategy,
     llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
   });
-  const outPath = import_node_path6.default.resolve(projectRoot, String(flags.out));
+  const outPath = import_node_path3.default.resolve(projectRoot, String(flags.out));
   const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-  await import_promises6.default.mkdir(import_node_path6.default.dirname(outPath), { recursive: true });
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
   await Promise.all([
-    import_promises6.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+    import_promises3.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-    import_promises6.default.writeFile(
+    import_promises3.default.writeFile(
       markdownPath,
       formatRuntimeScorecardMarkdown(scorecard),
       "utf8"
@@ -2145,7 +1730,7 @@ var runtimeScorecard = async () => {
   const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
   const strategyReleaseRoot = resolveOptionalPath(flags.strategyReleaseRoot);
   if (diagnosis && diagnosisPath) {
-    await import_promises6.default.writeFile(
+    await import_promises3.default.writeFile(
       diagnosisPath,
       `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -2166,7 +1751,7 @@ var runtimeScorecard = async () => {
         composition: verifiedRelease?.manifest.composition,
         sourceArtifacts: await Promise.all(
           sourcePaths.map(async (sourcePath) => ({
-            artifactId: import_node_path6.default.basename(sourcePath),
+            artifactId: import_node_path3.default.basename(sourcePath),
             path: sourcePath,
             sha256: await sha256File(sourcePath)
           }))
@@ -2176,12 +1761,12 @@ var runtimeScorecard = async () => {
   }
   let receiptPath2 = null;
   if (flags.markProcessed) {
-    const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
-      import_node_path6.default.dirname(runtimeEvidencePath)
+    const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
+      import_node_path3.default.dirname(runtimeEvidencePath)
     );
-    const feedbackSource = replayEvidencePath ? await verifyRuntimeFeedbackReplaySource({
-      bundleDir: import_node_path6.default.dirname(replayEvidencePath),
-      runtimeEvidenceBundleDir: import_node_path6.default.dirname(runtimeEvidencePath)
+    const feedbackSource = replayEvidencePath ? await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplaySource)({
+      bundleDir: import_node_path3.default.dirname(replayEvidencePath),
+      runtimeEvidenceBundleDir: import_node_path3.default.dirname(runtimeEvidencePath)
     }).catch((error) => {
       if (runtimeEvidenceBundle.artifact.producer) throw error;
       return null;
@@ -2192,9 +1777,9 @@ var runtimeScorecard = async () => {
       );
     }
     receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-      evidenceRoot: import_node_path6.default.resolve(projectRoot, String(flags.evidenceDir)),
+      evidenceRoot: import_node_path3.default.resolve(projectRoot, String(flags.evidenceDir)),
       deploymentId: String(flags.deployment),
-      bundleDir: import_node_path6.default.dirname(runtimeEvidencePath),
+      bundleDir: import_node_path3.default.dirname(runtimeEvidencePath),
       scorecardPath: outPath,
       runtimeFeedback: feedbackSource ? {
         artifactId: feedbackSource.feedback.manifest.artifactId,