@tradejs/cli 3.1.21 → 3.1.22-beta.238

package/dist/lib/runtimeFeedbackSync.js

@@ -0,0 +1,350 @@
+"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/lib/runtimeFeedbackSync.ts
+var runtimeFeedbackSync_exports = {};
+__export(runtimeFeedbackSync_exports, {
+  syncRuntimeFeedbackReplayBundles: () => syncRuntimeFeedbackReplayBundles
+});
+module.exports = __toCommonJS(runtimeFeedbackSync_exports);
+var import_node_child_process2 = require("child_process");
+var import_promises5 = __toESM(require("fs/promises"));
+var import_node_path5 = __toESM(require("path"));
+var import_node_util2 = require("util");
+
+// 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/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 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) : [];
+
+// 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/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 sha256 = (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 parseManifest = (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 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 = parseManifest(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 (sha256(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 discoverRuntimeFeedbackReplayBundles = async (rootDir) => {
+  const bundles = [];
+  const visit = async (directory, depth) => {
+    if (depth > 10) return;
+    let entries;
+    try {
+      entries = await import_promises3.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_FEEDBACK_MANIFEST_FILE) && names.has(RUNTIME_FEEDBACK_REPLAY_FILE) && names.has(RUNTIME_FEEDBACK_LOG_FILE) && names.has(RUNTIME_FEEDBACK_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_path3.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_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 withTrailingSlash = (value) => value.endsWith("/") ? value : `${value}/`;
+var buildRuntimeEvidenceRsyncArgs = ({
+  source,
+  destination
+}) => [
+  "--recursive",
+  "--times",
+  "--partial",
+  "--partial-dir=.rsync-partial",
+  "--prune-empty-dirs",
+  withTrailingSlash(source),
+  withTrailingSlash(destination)
+];
+
+// src/lib/runtimeFeedbackSync.ts
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var isExistingDestinationError = (error) => {
+  const code = error.code;
+  return code === "EEXIST" || code === "ENOTEMPTY";
+};
+var safeSegment = (value, fallback) => {
+  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+  return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+};
+var dateParts = (timestamp) => {
+  const date = new Date(timestamp);
+  return [
+    String(date.getUTCFullYear()),
+    String(date.getUTCMonth() + 1).padStart(2, "0"),
+    String(date.getUTCDate()).padStart(2, "0")
+  ];
+};
+var syncRuntimeFeedbackReplayBundles = async ({
+  source,
+  feedbackRoot,
+  deploymentId,
+  runRsync = async (args) => {
+    const result = await execFileAsync2("rsync", args, {
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return { stdout: result.stdout, stderr: result.stderr };
+  }
+}) => {
+  const safeDeploymentId = safeSegment(deploymentId, "production");
+  const inboxRoot = import_node_path5.default.join(feedbackRoot, "inbox", safeDeploymentId);
+  const artifactsRoot = import_node_path5.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+  await Promise.all([
+    import_promises5.default.mkdir(inboxRoot, { recursive: true }),
+    import_promises5.default.mkdir(artifactsRoot, { recursive: true })
+  ]);
+  const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
+    source,
+    destination: inboxRoot
+  });
+  const transfer = await runRsync(rsyncArgs);
+  const discovered = await discoverRuntimeFeedbackReplayBundles(inboxRoot);
+  const received = [];
+  for (const bundleDir of discovered) {
+    const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+    if (verified.manifest.deploymentId !== safeDeploymentId) {
+      throw new Error(
+        `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
+      );
+    }
+    const destinationDir = import_node_path5.default.join(
+      artifactsRoot,
+      ...dateParts(verified.manifest.window.endTime),
+      safeSegment(verified.manifest.runtimeEvidence.artifactId, "artifact"),
+      safeSegment(verified.manifest.runId, "run")
+    );
+    await import_promises5.default.mkdir(import_node_path5.default.dirname(destinationDir), { recursive: true });
+    try {
+      await import_promises5.default.rename(bundleDir, destinationDir);
+    } catch (error) {
+      if (!isExistingDestinationError(error)) throw error;
+      const existing = await verifyRuntimeFeedbackReplayBundle(destinationDir);
+      if (existing.manifest.payloads.replayEvidence.sha256 !== verified.manifest.payloads.replayEvidence.sha256) {
+        throw new Error(
+          `Conflicting runtime feedback replay ${verified.manifest.artifactId}`
+        );
+      }
+      await import_promises5.default.rm(bundleDir, { recursive: true, force: true });
+    }
+    received.push(await verifyRuntimeFeedbackReplayBundle(destinationDir));
+  }
+  return {
+    rsyncArgs,
+    stdout: String(transfer.stdout ?? ""),
+    stderr: String(transfer.stderr ?? ""),
+    received
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  syncRuntimeFeedbackReplayBundles
+});

package/dist/scripts/replay.js

@@ -4888,12 +4888,15 @@ var getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly
 var buildReplayStrategyConfig = ({
   strategyConfig,
   interval
-}) => buildRuntimeModeStrategyConfig({
-  strategyConfig,
-  env: "PARITY",
-  interval,
-  makeOrders: true,
-  recordRuntimeTrades: false
+}) => ({
+  ...buildRuntimeModeStrategyConfig({
+    strategyConfig,
+    env: "PARITY",
+    interval,
+    makeOrders: false,
+    recordRuntimeTrades: false
+  }),
+  SIMULATE_ORDERS: true
 });
 var toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var compactReplayAdditionalIndicators = (additionalIndicators) => {

package/dist/scripts/replayRunner.js

@@ -4891,12 +4891,15 @@ var getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly
 var buildReplayStrategyConfig = ({
   strategyConfig,
   interval
-}) => buildRuntimeModeStrategyConfig({
-  strategyConfig,
-  env: "PARITY",
-  interval,
-  makeOrders: true,
-  recordRuntimeTrades: false
+}) => ({
+  ...buildRuntimeModeStrategyConfig({
+    strategyConfig,
+    env: "PARITY",
+    interval,
+    makeOrders: false,
+    recordRuntimeTrades: false
+  }),
+  SIMULATE_ORDERS: true
 });
 var toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var compactReplayAdditionalIndicators = (additionalIndicators) => {

package/dist/scripts/replayRuntimeEvidence.js

@@ -728,6 +728,10 @@ var replayRuntimeEvidence = async () => {
       availableKeys: replay.availableKeys,
       startedAt: replayValue.startedAt ?? null,
       finishedAt: replayValue.finishedAt ?? null,
+      durationSeconds: replayValue.durationSeconds ?? null,
+      cycleCount: replayValue.cycleCount ?? null,
+      abortedCycles: replayValue.abortedCycles ?? null,
+      signalsCount: replayValue.signalsCount ?? null,
       resultsByStrategies: asArray(replayValue.resultsByStrategies).filter(
         (row) => !strategies.length || strategies.includes(String(row.strategyName ?? ""))
       ),

package/dist/scripts/runtimeEvidence.js

@@ -34,8 +34,8 @@ __export(runtimeEvidence_exports, {
   runtimeEvidence: () => runtimeEvidence
 });
 module.exports = __toCommonJS(runtimeEvidence_exports);
-var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
+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"));
 
@@ -874,6 +874,56 @@ var runtimeLineageKey = (lineage) => [
   lineage.runtimePackageVersion
 ].join(":");
 
+// src/lib/runtimeEvidenceProducer.ts
+var import_node_crypto3 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var sha2562 = (value) => (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
+var resolveRuntimeEvidenceProducer = async ({
+  projectRoot: projectRoot2,
+  required
+}) => {
+  const projectSha = String(process.env.TRADEJS_PROJECT_SHA ?? "").trim();
+  const imageDigest = String(
+    process.env.TRADEJS_PROJECT_IMAGE_DIGEST ?? ""
+  ).trim();
+  if (!projectSha && !imageDigest && !required) {
+    return null;
+  }
+  if (!/^[a-f0-9]{40}$/.test(projectSha)) {
+    throw new Error(
+      "TRADEJS_PROJECT_SHA must be a full lowercase Git SHA before publishing runtime evidence"
+    );
+  }
+  if (!/^sha256:[a-f0-9]{64}$/.test(imageDigest)) {
+    throw new Error(
+      "TRADEJS_PROJECT_IMAGE_DIGEST must be an immutable sha256 digest before publishing runtime evidence"
+    );
+  }
+  const manifestPath = import_node_path2.default.join(projectRoot2, "runtime-package-manifest.json");
+  let manifest;
+  try {
+    manifest = await import_promises2.default.readFile(manifestPath);
+  } catch (error) {
+    if (!required && error.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(
+      `Runtime package manifest is required for runtime evidence: ${manifestPath}`,
+      { cause: error }
+    );
+  }
+  return {
+    schemaVersion: 1,
+    projectSha,
+    imageDigest,
+    runtimePackageManifest: {
+      file: "runtime-package-manifest.json",
+      sha256: sha2562(manifest)
+    }
+  };
+};
+
 // src/scripts/runtimeEvidence.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -954,6 +1004,11 @@ var parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) =
 var runtimeEvidence = async () => {
   const { startTime, endTime, source } = resolveWindow();
   const deploymentId = String(flags.deployment);
+  const publishDir = String(flags.publishDir ?? "").trim();
+  const producer = await resolveRuntimeEvidenceProducer({
+    projectRoot,
+    required: Boolean(publishDir)
+  });
   const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
     userName: String(flags.user),
     projectRoot,
@@ -1025,6 +1080,7 @@ var runtimeEvidence = async () => {
   const artifact = {
     reportType: "runtime-evidence",
     generatedAt: Date.now(),
+    ...producer ? { producer } : {},
     userName: flags.user,
     window: {
       startTime,
@@ -1037,13 +1093,12 @@ var runtimeEvidence = async () => {
     deployment,
     runtime
   };
-  const outPath = import_node_path2.default.resolve(projectRoot, String(flags.out));
-  await import_promises2.default.mkdir(import_node_path2.default.dirname(outPath), { recursive: true });
-  await import_promises2.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+  const outPath = import_node_path3.default.resolve(projectRoot, String(flags.out));
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
+  await import_promises3.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
-  const publishDir = String(flags.publishDir ?? "").trim();
   const published = publishDir ? await publishRuntimeEvidenceBundle({
-    publishRoot: import_node_path2.default.resolve(projectRoot, publishDir),
+    publishRoot: import_node_path3.default.resolve(projectRoot, publishDir),
     deploymentId,
     userName: String(flags.user),
     startTime,