@tradejs/cli 2.0.14 → 2.0.16

package/dist/scripts/runtimeEvidence.js

@@ -34,8 +34,8 @@ __export(runtimeEvidence_exports, {
   runtimeEvidence: () => runtimeEvidence
 });
 module.exports = __toCommonJS(runtimeEvidence_exports);
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __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"));
 
@@ -134,6 +134,29 @@ var loadRuntimeTrades = async (userName, {
   const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
   return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
+var loadRuntimeClosedTrades = async (userName, {
+  startTime,
+  endTime
+}) => {
+  const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+  const trades = (await Promise.all(
+    dayKeys.map(
+      (dayKey) => (0, import_redis.getHashJsonValues)(
+        import_redis.redisKeys.runtimeClosedTradeBucket(userName, dayKey)
+      )
+    )
+  )).flat();
+  const deduped = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    if (!isRuntimeTradeRecord(trade) || trade.status !== "closed" || !Number.isFinite(trade.exitTimestamp) || trade.exitTimestamp < startTime || trade.exitTimestamp >= endTime) {
+      continue;
+    }
+    deduped.set(trade.orderId, trade);
+  }
+  return [...deduped.values()].sort(
+    (left, right) => left.exitTimestamp - right.exitTimestamp
+  );
+};
 
 // src/lib/runtimeSignalsLoader.ts
 var import_redis2 = require("@tradejs/infra/redis");
@@ -298,11 +321,6 @@ var formatRuntimeDebugDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU",
   minute: "2-digit",
   hour12: false
 }).format(new Date(timestamp));
-var buildRuntimeDebugEvaluationId = ({
-  strategy,
-  symbol,
-  timestamp
-}) => `${strategy}:${symbol}:${timestamp}`;
 var filterByStrategies = (values, strategies) => {
   if (!strategies?.length) {
     return values;
@@ -318,13 +336,30 @@ var collectRuntimeDebugEvidence = async ({
 }) => {
   const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
   const dayKeySet = new Set(dayKeys);
-  const [trades, signals, evaluations, evaluationStatsBuckets, configs] = await Promise.all([
+  const [
+    entryTrades,
+    closedTrades,
+    signals,
+    evaluations,
+    evaluationStatsBuckets,
+    configs
+  ] = await Promise.all([
     loadRuntimeTrades(userName, { startTime, endTime }),
+    loadRuntimeClosedTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
     loadRuntimeStrategyConfigs(userName)
   ]);
+  const tradesByOrderId = new Map(
+    entryTrades.map((trade) => [trade.orderId, trade])
+  );
+  for (const trade of closedTrades) {
+    tradesByOrderId.set(trade.orderId, trade);
+  }
+  const trades = [...tradesByOrderId.values()].sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
   const filteredStats = evaluationStatsBuckets.filter(
     (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
   );
@@ -339,7 +374,7 @@ var collectRuntimeDebugEvidence = async ({
     )
   };
 };
-var buildRuntimeDebugReportPayload = async ({
+var buildRuntimeEvidenceReportPayload = ({
   userName,
   startTime,
   endTime,
@@ -348,160 +383,230 @@ var buildRuntimeDebugReportPayload = async ({
   trades,
   strategyConfigs,
   evaluationStatsBuckets
-}) => {
-  const signalById = new Map(
-    signals.map((signal) => [signal.signalId, signal])
-  );
-  const evaluationById = new Map(
-    evaluations.map((evaluation) => [evaluation.evaluationId, evaluation])
-  );
-  const evaluationBySignalShape = new Map(
-    evaluations.map((evaluation) => [
-      buildRuntimeDebugEvaluationId(evaluation),
-      evaluation
-    ])
-  );
-  const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
-  const debugTrades = await Promise.all(
-    trades.map(async (trade) => {
-      const signal = trade.signalId != null ? signalById.get(trade.signalId) : void 0;
-      const evaluationId = buildRuntimeDebugEvaluationId({
-        strategy: trade.strategy,
-        symbol: trade.symbol,
-        timestamp: signal?.timestamp ?? trade.entryTimestamp
-      });
-      const knownEvaluation = evaluationById.get(evaluationId) ?? evaluationBySignalShape.get(evaluationId);
-      const tradeDayKey = (0, import_time2.getRuntimeStorageDayKey)(trade.entryTimestamp);
-      const signalDayKey = signal != null ? (0, import_time2.getRuntimeStorageDayKey)(signal.timestamp) : tradeDayKey;
-      const evaluationDayKey = knownEvaluation != null ? (0, import_time2.getRuntimeStorageDayKey)(knownEvaluation.timestamp) : signalDayKey;
-      const tradeKey = import_redis3.redisKeys.runtimeTrade(userName, trade.orderId);
-      const tradeBucketKey = import_redis3.redisKeys.runtimeTradeBucket(
-        userName,
-        tradeDayKey
-      );
-      const activeTradeKey = import_redis3.redisKeys.runtimeActiveTrade(
-        userName,
-        trade.symbol,
-        trade.deploymentId ?? trade.accountId
-      );
-      const signalKey = trade.signalId != null ? import_redis3.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
-      const evaluationBucketKey = import_redis3.redisKeys.runtimeSignalEvaluationBucket(
-        userName,
-        evaluationDayKey,
-        knownEvaluation?.strategy ?? trade.strategy
-      );
-      const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
-      const evaluationKey = import_redis3.redisKeys.runtimeSignalEvaluation(
-        userName,
-        evaluationField
-      );
-      const [
-        tradeValue,
-        activeTradeValue,
-        signalValue,
-        directEvaluationValue,
-        bucketEvaluationValue
-      ] = await Promise.all([
-        (0, import_redis3.getData)(tradeKey, null),
-        (0, import_redis3.getData)(activeTradeKey, null),
-        signalKey ? (0, import_redis3.getData)(signalKey, null) : Promise.resolve(null),
-        (0, import_redis3.getData)(evaluationKey, null),
-        knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis3.getHashJsonField)(
-          evaluationBucketKey,
-          evaluationField,
-          null
-        )
-      ]);
-      const evaluationValue = directEvaluationValue ?? bucketEvaluationValue ?? knownEvaluation ?? null;
-      return {
-        redisDebug: {
-          trade: tradeKey,
-          tradeBucket: {
-            key: tradeBucketKey,
-            field: trade.orderId
-          },
-          activeTrade: activeTradeKey,
-          signal: signalKey,
-          evaluation: {
-            key: evaluationBucketKey,
-            field: evaluationField,
-            directKey: evaluationKey
-          }
-        },
-        trade,
-        redisValues: {
-          trade: tradeValue,
-          tradeBucket: trade,
-          activeTrade: activeTradeValue,
-          signal: signalValue ?? signal ?? null,
-          evaluation: evaluationValue ?? knownEvaluation ?? null
-        }
-      };
-    })
-  );
-  const linkedEvaluations = /* @__PURE__ */ new Map();
-  for (const trade of debugTrades) {
-    const evaluation = trade.redisValues.evaluation;
-    if (evaluation && typeof evaluation === "object" && "evaluationId" in evaluation && typeof evaluation.evaluationId === "string") {
-      linkedEvaluations.set(
-        evaluation.evaluationId,
-        evaluation
-      );
-    }
+}) => ({
+  reportType: "runtime-daily-evidence",
+  generatedAt: Date.now(),
+  userName,
+  window: {
+    startTime,
+    endTime,
+    startMsk: formatRuntimeDebugDateTime(startTime),
+    endMsk: formatRuntimeDebugDateTime(endTime),
+    dayKeys: (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime)
+  },
+  counts: {
+    trades: trades.length,
+    signals: signals.length,
+    evaluations: evaluations.length,
+    evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+    strategyConfigs: strategyConfigs?.length ?? 0
+  },
+  trades: trades.map((trade) => ({ trade })),
+  signals: signals.map((signal) => ({ signal })),
+  evaluations: evaluations.map((evaluation) => ({ evaluation })),
+  evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+  strategyConfigs: strategyConfigs ?? []
+});
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
+var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
+var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+var 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 compactTimestamp = (timestamp) => new Date(timestamp).toISOString().replace(/[-:]/g, "").replace(/\.000Z$/, "Z");
+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 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");
   }
-  const reportEvaluations = evaluations.length > 0 ? evaluations : [...linkedEvaluations.values()];
   return {
-    reportType: "runtime-daily-debug",
-    generatedAt: Date.now(),
-    generatedAtMsk: formatRuntimeDebugDateTime(Date.now()),
-    userName,
+    schemaVersion: 1,
+    artifactId: manifest.artifactId,
+    reportType: "runtime-evidence",
+    deploymentId: manifest.deploymentId,
+    userName: manifest.userName,
+    createdAt: manifest.createdAt,
     window: {
-      startTime,
-      endTime,
-      startMsk: formatRuntimeDebugDateTime(startTime),
-      endMsk: formatRuntimeDebugDateTime(endTime),
-      dayKeys
+      startTime: assertFiniteTimestamp(window?.startTime, "window.startTime"),
+      endTime: assertFiniteTimestamp(window?.endTime, "window.endTime")
     },
-    redisPrefixes: {
-      runtimeTrades: import_redis3.redisKeys.runtimeTrades(userName),
-      runtimeTradeBuckets: import_redis3.redisKeys.runtimeTradeBuckets(userName),
-      runtimeActiveTrades: import_redis3.redisKeys.runtimeActiveTrades(userName),
-      runtimeSignals: import_redis3.redisKeys.runtimeSignalBuckets(userName),
-      runtimeSignalEvaluations: import_redis3.redisKeys.runtimeSignalEvaluationBuckets(userName),
-      runtimeSignalEvaluationStats: import_redis3.redisKeys.runtimeSignalEvaluationStatsBuckets(userName)
+    payload: {
+      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
+      sha256: payload.sha256,
+      bytes: payload.bytes
     },
-    counts: {
-      trades: trades.length,
-      signals: signals.length,
-      evaluations: reportEvaluations.length,
-      evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
-      strategyConfigs: strategyConfigs?.length ?? 0
+    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 publishRuntimeEvidenceBundle = async ({
+  publishRoot,
+  deploymentId,
+  userName,
+  startTime,
+  endTime,
+  artifact,
+  counts,
+  lineageKeys
+}) => {
+  const payload = `${JSON.stringify(artifact, null, 2)}
+`;
+  const payloadSha256 = sha256(payload);
+  const safeDeploymentId = safeSegment(deploymentId, "default");
+  const artifactId = [
+    compactTimestamp(startTime),
+    compactTimestamp(endTime),
+    payloadSha256.slice(0, 16)
+  ].join("_");
+  const createdAt = Date.now();
+  const manifest = {
+    schemaVersion: 1,
+    artifactId,
+    reportType: "runtime-evidence",
+    deploymentId: safeDeploymentId,
+    userName,
+    createdAt,
+    window: { startTime, endTime },
+    payload: {
+      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
+      sha256: payloadSha256,
+      bytes: Buffer.byteLength(payload)
     },
-    trades: debugTrades,
-    signals: signals.map((signal) => ({
-      redisKey: import_redis3.redisKeys.storeSignal(signal.symbol, signal.signalId),
-      signal
-    })),
-    evaluations: reportEvaluations.map((evaluation) => ({
-      redisDebug: {
-        key: import_redis3.redisKeys.runtimeSignalEvaluationBucket(
-          userName,
-          (0, import_time2.getRuntimeStorageDayKey)(evaluation.timestamp),
-          evaluation.strategy
-        ),
-        field: evaluation.evaluationId,
-        directKey: import_redis3.redisKeys.runtimeSignalEvaluation(
-          userName,
-          evaluation.evaluationId
-        )
-      },
-      evaluation
-    })),
-    evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-    strategyConfigs: strategyConfigs ?? []
+    counts,
+    lineageKeys: [...new Set(lineageKeys)].sort()
+  };
+  const incomingRoot = import_node_path.default.join(publishRoot, "incoming");
+  const readyRoot = import_node_path.default.join(
+    publishRoot,
+    "ready",
+    safeDeploymentId,
+    ...dateParts(endTime)
+  );
+  const bundleDir = import_node_path.default.join(readyRoot, artifactId);
+  const temporaryDir = import_node_path.default.join(
+    incomingRoot,
+    `${artifactId}.tmp-${(0, import_node_crypto.randomUUID)()}`
+  );
+  await import_promises.default.mkdir(temporaryDir, { recursive: true });
+  try {
+    await Promise.all([
+      import_promises.default.writeFile(
+        import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_PAYLOAD_FILE),
+        payload,
+        "utf8"
+      ),
+      import_promises.default.writeFile(
+        import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_MANIFEST_FILE),
+        `${JSON.stringify(manifest, null, 2)}
+`,
+        "utf8"
+      )
+    ]);
+    await import_promises.default.writeFile(
+      import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_COMPLETE_FILE),
+      `${artifactId}
+`,
+      "utf8"
+    );
+    await import_promises.default.mkdir(readyRoot, { recursive: true });
+    try {
+      await import_promises.default.rename(temporaryDir, bundleDir);
+    } catch (error) {
+      if (!isExistingDestinationError(error)) {
+        throw error;
+      }
+      await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
+    throw error;
+  }
+  return verifyRuntimeEvidenceBundle(bundleDir);
+};
+var verifyRuntimeEvidenceBundle = async (bundleDir) => {
+  const manifestPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_MANIFEST_FILE);
+  const payloadPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_PAYLOAD_FILE);
+  const completePath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_COMPLETE_FILE);
+  const [manifestText, payload, completeText] = await Promise.all([
+    import_promises.default.readFile(manifestPath, "utf8"),
+    import_promises.default.readFile(payloadPath),
+    import_promises.default.readFile(completePath, "utf8")
+  ]);
+  const manifest = parseManifest(JSON.parse(manifestText));
+  if (completeText.trim() !== manifest.artifactId) {
+    throw new Error(`Invalid completion marker in ${bundleDir}`);
+  }
+  if (payload.byteLength !== manifest.payload.bytes) {
+    throw new Error(`Runtime evidence size mismatch in ${bundleDir}`);
+  }
+  if (sha256(payload) !== manifest.payload.sha256) {
+    throw new Error(`Runtime evidence checksum mismatch in ${bundleDir}`);
+  }
+  const artifact = asRecord(JSON.parse(payload.toString("utf8")));
+  const artifactWindow = asRecord(artifact?.window);
+  if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
+    throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
+  }
+  return {
+    bundleDir,
+    manifestPath,
+    payloadPath,
+    manifest,
+    artifact
   };
 };
 
+// src/lib/runtimeLineage.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_types = require("@tradejs/types");
+var import_strategies = require("@tradejs/node/strategies");
+var runtimeLineageKey = (lineage) => [
+  lineage.schemaVersion,
+  lineage.gitSha ?? "unknown",
+  lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
+  lineage.gateFingerprint,
+  lineage.configFingerprint,
+  lineage.contextFingerprint
+].join(":");
+
 // src/scripts/runtimeEvidence.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -514,8 +619,22 @@ import_args.default.option(
   "Fallback window in hours when start/end are omitted",
   24
 );
+import_args.default.option(
+  "daily",
+  "Use the latest complete 21:00 MSK to 21:00 MSK window",
+  false
+);
 import_args.default.option(["s", "strategy"], "Strategy filter, comma-separated");
 import_args.default.option(["o", "out"], "Output JSON path", "output/runtime-evidence.json");
+import_args.default.option(
+  "publishDir",
+  "Publish an immutable bundle under <dir>/ready/<deployment>"
+);
+import_args.default.option(
+  "deployment",
+  "Deployment id used by immutable evidence bundles",
+  process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
+);
 var flags = import_args.default.parse(process.argv);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var toEpochMs = (value) => {
@@ -531,12 +650,28 @@ var toEpochMs = (value) => {
   return Number.isFinite(parsed) ? parsed : null;
 };
 var resolveWindow = () => {
-  const endTime = toEpochMs(flags.endTime) ?? Date.now();
+  const explicitStartTime = toEpochMs(flags.startTime);
+  const explicitEndTime = toEpochMs(flags.endTime);
+  const now = Date.now();
+  const dailyEndTime = (() => {
+    if (!flags.daily || explicitStartTime != null || explicitEndTime != null) {
+      return null;
+    }
+    const date = new Date(now);
+    const boundary = Date.UTC(
+      date.getUTCFullYear(),
+      date.getUTCMonth(),
+      date.getUTCDate(),
+      18
+    );
+    return now >= boundary ? boundary : boundary - 24 * 60 * 60 * 1e3;
+  })();
+  const endTime = explicitEndTime ?? dailyEndTime ?? now;
   const hours = Math.max(
     1,
     Number.parseInt(String(flags.hours ?? 24), 10) || 24
   );
-  const startTime = toEpochMs(flags.startTime) ?? endTime - hours * 60 * 60 * 1e3;
+  const startTime = explicitStartTime ?? endTime - hours * 60 * 60 * 1e3;
   if (startTime >= endTime) {
     throw new Error(
       `Invalid window: startTime (${startTime}) must be less than endTime (${endTime})`
@@ -545,7 +680,7 @@ var resolveWindow = () => {
   return {
     startTime,
     endTime,
-    source: flags.startTime != null || flags.endTime != null ? "explicit" : "hours"
+    source: explicitStartTime != null || explicitEndTime != null ? "explicit" : dailyEndTime != null ? "daily" : "hours"
   };
 };
 var parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
@@ -558,7 +693,7 @@ var runtimeEvidence = async () => {
     endTime,
     strategies: strategies.length ? strategies : void 0
   });
-  const runtime = await buildRuntimeDebugReportPayload({
+  const runtime = buildRuntimeEvidenceReportPayload({
     userName: flags.user,
     startTime,
     endTime,
@@ -582,11 +717,31 @@ var runtimeEvidence = async () => {
     strategies,
     runtime
   };
-  const outPath = import_node_path.default.resolve(projectRoot, String(flags.out));
-  await import_promises.default.mkdir(import_node_path.default.dirname(outPath), { recursive: true });
-  await import_promises.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_path3.default.resolve(projectRoot, publishDir),
+    deploymentId: String(flags.deployment),
+    userName: String(flags.user),
+    startTime,
+    endTime,
+    artifact,
+    counts: artifact.runtime.counts,
+    lineageKeys: [
+      ...evidence.signals.map((signal) => signal.runtimeLineage),
+      ...evidence.evaluations.map(
+        (evaluation) => evaluation.runtimeLineage
+      ),
+      ...evidence.trades.map((trade) => trade.runtimeLineage)
+    ].filter((lineage) => lineage != null).map(runtimeLineageKey)
+  }) : null;
   console.log(import_chalk.default.green(`Wrote ${outPath}`));
+  if (published) {
+    console.log(import_chalk.default.green(`Published ${published.bundleDir}`));
+  }
   console.log(
     JSON.stringify(
       {