@tradejs/cli 3.1.21 → 3.1.22

package/dist/scripts/runtimeScorecard.js

@@ -34,9 +34,9 @@ __export(runtimeScorecard_exports, {
   runtimeScorecard: () => runtimeScorecard
 });
 module.exports = __toCommonJS(runtimeScorecard_exports);
-var import_promises4 = __toESM(require("fs/promises"));
-var import_node_crypto4 = require("crypto");
-var import_node_path4 = __toESM(require("path"));
+var import_promises6 = __toESM(require("fs/promises"));
+var import_node_crypto6 = require("crypto");
+var import_node_path6 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -316,22 +316,177 @@ var discoverRuntimeEvidenceBundles = async (rootDir) => {
   return bundles.sort();
 };
 
-// src/lib/runtimeEvidenceSync.ts
-var import_node_child_process = require("child_process");
+// 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 };
+};
+
+// 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_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 receiptPath = (receiptsRoot, artifactId) => import_node_path4.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
 var markRuntimeEvidenceBundleProcessed = async ({
   evidenceRoot,
   deploymentId,
   bundleDir,
-  scorecardPath
+  scorecardPath,
+  runtimeFeedback
 }) => {
   const safeDeploymentId = safeSegment(deploymentId, "production");
   const verified = await verifyRuntimeEvidenceBundle(bundleDir);
@@ -340,29 +495,33 @@ var markRuntimeEvidenceBundleProcessed = async ({
       `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
     );
   }
-  const receiptsRoot = import_node_path2.default.join(evidenceRoot, "receipts", safeDeploymentId);
+  const receiptsRoot = import_node_path4.default.join(evidenceRoot, "receipts", safeDeploymentId);
   const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
   const temporaryPath = `${finalPath}.tmp-${process.pid}`;
   const receipt = {
-    schemaVersion: 1,
+    schemaVersion: runtimeFeedback ? 2 : 1,
     artifactId: verified.manifest.artifactId,
     payloadSha256: verified.manifest.payload.sha256,
     processedAt: Date.now(),
-    scorecardPath: scorecardPath ?? null
+    scorecardPath: scorecardPath ?? null,
+    ...runtimeFeedback ? {
+      runtimeFeedbackArtifactId: runtimeFeedback.artifactId,
+      replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
+    } : {}
   };
-  await import_promises2.default.mkdir(receiptsRoot, { recursive: true });
-  await import_promises2.default.writeFile(
+  await import_promises4.default.mkdir(receiptsRoot, { recursive: true });
+  await import_promises4.default.writeFile(
     temporaryPath,
     `${JSON.stringify(receipt, null, 2)}
 `,
     "utf8"
   );
-  await import_promises2.default.rename(temporaryPath, finalPath);
+  await import_promises4.default.rename(temporaryPath, finalPath);
   return finalPath;
 };
 
 // src/lib/runtimeLineage.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -374,7 +533,7 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
 var runtimeLineageKey = (lineage) => [
   "v3",
   lineage.deploymentCompositionId,
@@ -1089,9 +1248,9 @@ ${reactions}
 };
 
 // src/lib/strategyRelease.ts
-var import_node_crypto3 = require("crypto");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
+var import_node_crypto5 = require("crypto");
+var import_promises5 = __toESM(require("fs/promises"));
+var import_node_path5 = __toESM(require("path"));
 var import_types2 = require("@tradejs/types");
 var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
@@ -1565,10 +1724,10 @@ var createStrategyReleaseManifest = (input) => {
     strategy: input.strategy,
     createdAt: input.createdAt,
     compositionId,
-    evidence: input.evidence.map(({ kind, artifactId, sha256: sha2562 }) => ({
+    evidence: input.evidence.map(({ kind, artifactId, sha256: sha2563 }) => ({
       kind,
       artifactId,
-      sha256: sha2562
+      sha256: sha2563
     })),
     verdict
   };
@@ -1592,7 +1751,7 @@ var createStrategyReleaseManifest = (input) => {
   };
 };
 var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises3.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises5.default.readFile(valueOrPath, "utf8")) : valueOrPath;
   const envelope = value;
   assert(
     envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -1643,19 +1802,19 @@ var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
   return envelope;
 };
 var verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises3.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises5.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_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
-  await import_promises3.default.writeFile(
+  await import_promises5.default.mkdir(import_node_path5.default.dirname(filePath), { recursive: true });
+  await import_promises5.default.writeFile(
     temporaryPath,
     `${canonicalStrategyReleaseJson(value)}
 `,
     "utf8"
   );
-  await import_promises3.default.rename(temporaryPath, filePath);
+  await import_promises5.default.rename(temporaryPath, filePath);
 };
 var publishStrategyLiveDiagnosis = async ({
   rootDir,
@@ -1721,13 +1880,13 @@ var publishStrategyLiveDiagnosis = async ({
     markers,
     sourceArtifacts
   });
-  const diagnosisPath = import_node_path3.default.join(
+  const diagnosisPath = import_node_path5.default.join(
     rootDir,
     "diagnoses",
     safeSegment2(diagnosis.strategy, "strategy"),
     `${diagnosisId}.json`
   );
-  const markerPath = import_node_path3.default.join(
+  const markerPath = import_node_path5.default.join(
     rootDir,
     "markers",
     safeSegment2(diagnosis.strategy, "strategy"),
@@ -1799,15 +1958,15 @@ 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_path4.default.resolve(projectRoot, raw) : null;
+  return raw ? import_node_path6.default.resolve(projectRoot, raw) : null;
 };
-var readJson = async (filePath) => filePath ? JSON.parse(await import_promises4.default.readFile(filePath, "utf8")) : void 0;
+var readJson = async (filePath) => filePath ? JSON.parse(await import_promises6.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_crypto4.createHash)("sha256").update(await import_promises4.default.readFile(filePath)).digest("hex");
+var sha256File = async (filePath) => (0, import_node_crypto6.createHash)("sha256").update(await import_promises6.default.readFile(filePath)).digest("hex");
 var loadHistoryArtifacts = async (historyDir) => {
   if (!historyDir) return [];
   const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
@@ -1877,13 +2036,13 @@ var runtimeScorecard = async () => {
     strategy: scorecardStrategy,
     llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
   });
-  const outPath = import_node_path4.default.resolve(projectRoot, String(flags.out));
+  const outPath = import_node_path6.default.resolve(projectRoot, String(flags.out));
   const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-  await import_promises4.default.mkdir(import_node_path4.default.dirname(outPath), { recursive: true });
+  await import_promises6.default.mkdir(import_node_path6.default.dirname(outPath), { recursive: true });
   await Promise.all([
-    import_promises4.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+    import_promises6.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-    import_promises4.default.writeFile(
+    import_promises6.default.writeFile(
       markdownPath,
       formatRuntimeScorecardMarkdown(scorecard),
       "utf8"
@@ -1897,7 +2056,7 @@ var runtimeScorecard = async () => {
   const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
   const strategyReleaseRoot = resolveOptionalPath(flags.strategyReleaseRoot);
   if (diagnosis && diagnosisPath) {
-    await import_promises4.default.writeFile(
+    await import_promises6.default.writeFile(
       diagnosisPath,
       `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -1918,7 +2077,7 @@ var runtimeScorecard = async () => {
         composition: verifiedRelease?.manifest.composition,
         sourceArtifacts: await Promise.all(
           sourcePaths.map(async (sourcePath) => ({
-            artifactId: import_node_path4.default.basename(sourcePath),
+            artifactId: import_node_path6.default.basename(sourcePath),
             path: sourcePath,
             sha256: await sha256File(sourcePath)
           }))
@@ -1928,11 +2087,30 @@ var runtimeScorecard = async () => {
   }
   let receiptPath2 = null;
   if (flags.markProcessed) {
+    const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
+      import_node_path6.default.dirname(runtimeEvidencePath)
+    );
+    const feedbackSource = replayEvidencePath ? await verifyRuntimeFeedbackReplaySource({
+      bundleDir: import_node_path6.default.dirname(replayEvidencePath),
+      runtimeEvidenceBundleDir: import_node_path6.default.dirname(runtimeEvidencePath)
+    }).catch((error) => {
+      if (runtimeEvidenceBundle.artifact.producer) throw error;
+      return null;
+    }) : null;
+    if (runtimeEvidenceBundle.artifact.producer && !feedbackSource) {
+      throw new Error(
+        "Image-bound runtime evidence requires a verified production replay bundle before it can be marked processed"
+      );
+    }
     receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-      evidenceRoot: import_node_path4.default.resolve(projectRoot, String(flags.evidenceDir)),
+      evidenceRoot: import_node_path6.default.resolve(projectRoot, String(flags.evidenceDir)),
       deploymentId: String(flags.deployment),
-      bundleDir: import_node_path4.default.dirname(runtimeEvidencePath),
-      scorecardPath: outPath
+      bundleDir: import_node_path6.default.dirname(runtimeEvidencePath),
+      scorecardPath: outPath,
+      runtimeFeedback: feedbackSource ? {
+        artifactId: feedbackSource.feedback.manifest.artifactId,
+        replayEvidenceSha256: feedbackSource.feedback.manifest.payloads.replayEvidence.sha256
+      } : null
     });
   }
   console.log(import_chalk.default.green(`Wrote ${outPath}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.21",
+  "version": "3.1.22",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -36,13 +36,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.21",
-    "@tradejs/core": "^3.1.21",
-    "@tradejs/indicators": "^3.1.21",
-    "@tradejs/infra": "^3.1.21",
-    "@tradejs/node": "^3.1.21",
+    "@tradejs/connectors": "^3.1.22",
+    "@tradejs/core": "^3.1.22",
+    "@tradejs/indicators": "^3.1.22",
+    "@tradejs/infra": "^3.1.22",
+    "@tradejs/node": "^3.1.22",
     "@tradejs/strategy-kit": "3.0.3",
-    "@tradejs/types": "^3.1.21",
+    "@tradejs/types": "^3.1.22",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",
@@ -84,6 +84,8 @@
     "signals": "yarn run run:dist signals",
     "results": "yarn run run:dist results",
     "replay-runtime-evidence": "yarn run run:dist replay-runtime-evidence",
+    "runtime-feedback-replay": "yarn run run:dist runtime-feedback-replay",
+    "runtime-feedback-sync": "yarn run run:dist runtime-feedback-sync",
     "runtime-evidence": "yarn run run:dist runtime-evidence",
     "runtime-evidence-sync": "yarn run run:dist runtime-evidence-sync",
     "runtime-scorecard": "yarn run run:dist runtime-scorecard",