@tradejs/cli 3.1.16-beta.230 → 3.1.17-beta.231

package/dist/scripts/runtimeEvidence.js

@@ -34,8 +34,8 @@ __export(runtimeEvidence_exports, {
   runtimeEvidence: () => runtimeEvidence
 });
 module.exports = __toCommonJS(runtimeEvidence_exports);
-var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path4 = __toESM(require("path"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -76,9 +76,7 @@ var loadRuntimeTrades = async (userName, {
       dedupedBucketTrades.set(trade.orderId, trade);
     }
     const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-    if (windowedTrades.length > 0 || dayKeys.length === 0) {
-      return windowedTrades;
-    }
+    return windowedTrades;
   }
   const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
   const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
@@ -318,16 +316,14 @@ var collectRuntimeDebugEvidence = async ({
     signals,
     evaluations,
     evaluationStatsBuckets,
-    lineageScopes,
-    configs
+    lineageScopes
   ] = await Promise.all([
     loadRuntimeTrades(userName, { startTime, endTime }),
     loadRuntimeClosedTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
-    loadRuntimeLineageScopes(userName, { startTime, endTime }),
-    (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName)
+    loadRuntimeLineageScopes(userName, { startTime, endTime })
   ]);
   const tradesByOrderId = new Map(
     entryTrades.map((trade) => [trade.orderId, trade])
@@ -352,9 +348,6 @@ var collectRuntimeDebugEvidence = async ({
     evaluationStatsBuckets: filteredStats,
     lineageScopes: lineageScopes.filter(matchesDeployment).filter(
       (scope) => !strategies?.length || strategies.includes(scope.strategy)
-    ),
-    strategyConfigs: deploymentId ? [] : configs.filter(
-      (config) => !strategies?.length || strategies.includes(config.strategyName)
     )
   };
 };
@@ -365,7 +358,6 @@ var buildRuntimeEvidenceReportPayload = ({
   signals,
   evaluations,
   trades,
-  strategyConfigs,
   evaluationStatsBuckets,
   lineageScopes
 }) => ({
@@ -384,21 +376,283 @@ var buildRuntimeEvidenceReportPayload = ({
     signals: signals.length,
     evaluations: evaluations.length,
     evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
-    lineageScopes: lineageScopes?.length ?? 0,
-    strategyConfigs: strategyConfigs?.length ?? 0
+    lineageScopes: lineageScopes?.length ?? 0
   },
   trades: trades.map((trade) => ({ trade })),
   signals: signals.map((signal) => ({ signal })),
   evaluations: evaluations.map((evaluation) => ({ evaluation })),
   evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-  lineageScopes: lineageScopes ?? [],
-  strategyConfigs: strategyConfigs ?? []
+  lineageScopes: lineageScopes ?? []
 });
 
 // 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"
+    );
+  }
+  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;
+};
+var resolveRuntimeEvidenceTickerUniverse = ({
+  deployment,
+  lineageScopes
+}) => {
+  const declaredTickers = deployment.tickers?.filter(isNonEmptyString) ?? [];
+  if (declaredTickers.length > 0) {
+    return {
+      ...deployment,
+      tickers: [
+        ...new Set(declaredTickers.map((ticker) => ticker.trim()))
+      ].sort()
+    };
+  }
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length > 0 && activeStrategies.every((strategy) => strategy.selection?.tickers?.length)) {
+    return {
+      ...deployment,
+      tickers: [
+        ...new Set(
+          activeStrategies.flatMap(
+            (strategy) => strategy.selection?.tickers ?? []
+          )
+        )
+      ].sort()
+    };
+  }
+  const strategiesByName = new Map(
+    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
+  );
+  const tickers = /* @__PURE__ */ new Set();
+  for (const scope of lineageScopes) {
+    const strategy = strategiesByName.get(scope.strategy);
+    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !runtimeLineageMatchesStrategySnapshot({
+      lineage: scope.lineage,
+      deployment,
+      strategy
+    })) {
+      continue;
+    }
+    tickers.add(scope.symbol.trim());
+  }
+  if (tickers.size === 0) {
+    throw new Error(
+      "Runtime evidence has no immutable ticker universe for the embedded deployment composition"
+    );
+  }
+  return { ...deployment, tickers: [...tickers].sort() };
+};
+var resolveRuntimeEvidenceDeploymentSnapshot = async ({
+  userName,
+  projectRoot: projectRoot2,
+  deploymentId
+}) => {
+  const [deployment, strategies] = await Promise.all([
+    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot: projectRoot2, deploymentId }),
+    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot: projectRoot2, deploymentId })
+  ]);
+  if (!deployment) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  return {
+    schemaVersion: 2,
+    id: deployment.id,
+    deploymentCompositionId: deployment.deploymentCompositionId,
+    label: deployment.label,
+    connectorName: deployment.connectorName,
+    provider: deployment.provider,
+    accountId: deployment.accountId,
+    enabled: deployment.enabled,
+    strategies: strategies.map(
+      ({
+        strategyName,
+        strategyRevision,
+        enabled,
+        controlState,
+        interval,
+        universe,
+        accountId,
+        strategyPackage,
+        strategyPackageVersion,
+        strategyDependencyVersions,
+        runtimePackageVersion,
+        strategyConfig,
+        selection
+      }) => ({
+        strategyName,
+        strategyRevision,
+        enabled,
+        controlState,
+        interval,
+        universe,
+        ...accountId ? { accountId } : {},
+        strategyPackage,
+        strategyPackageVersion,
+        strategyDependencyVersions,
+        runtimePackageVersion,
+        strategyConfig,
+        ...selection ? { selection } : {}
+      })
+    ),
+    ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+    ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+  };
+};
+
+// 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";
@@ -482,6 +736,7 @@ var publishRuntimeEvidenceBundle = async ({
   counts,
   lineageKeys
 }) => {
+  assertCurrentRuntimeEvidenceArtifact(artifact);
   const payload = `${JSON.stringify(artifact, null, 2)}
 `;
   const payloadSha256 = sha256(payload);
@@ -581,6 +836,10 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
   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,
@@ -591,21 +850,7 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
 };
 
 // src/lib/runtimeLineage.ts
-var import_node_child_process = require("child_process");
-var import_node_crypto3 = require("crypto");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
-var import_types = require("@tradejs/types");
-var import_strategies = require("@tradejs/node/strategies");
-var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
-
-// src/lib/strategyGateFingerprint.ts
 var import_node_crypto2 = require("crypto");
-var import_node_module = require("module");
-var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
-
-// src/lib/runtimeLineage.ts
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -617,153 +862,16 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
-var runtimeLineageKey = (lineage) => lineage.schemaVersion === 3 ? [
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var runtimeLineageKey = (lineage) => [
   "v3",
   lineage.deploymentCompositionId,
   lineage.strategyRevision,
   lineage.strategyPackageVersion,
-  `deps:${fingerprintRuntimeValue(
-    lineage.strategyDependencyVersions
-  ).slice(0, 16)}`,
+  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
   lineage.runtimePackageVersion
-].join(":") : [
-  lineage.schemaVersion,
-  lineage.compositionId ?? "unbound-composition",
-  lineage.gitSha ?? "unknown",
-  lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
-  lineage.gateFingerprint,
-  lineage.configFingerprint,
-  lineage.contextFingerprint
 ].join(":");
 
-// src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-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 lineageMatchesStrategySnapshot = ({
-  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 activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
-var resolveRuntimeEvidenceTickerUniverse = ({
-  deployment,
-  lineageScopes
-}) => {
-  const declaredTickers = deployment.tickers?.filter(isNonEmptyString) ?? [];
-  if (declaredTickers.length > 0) {
-    return {
-      ...deployment,
-      tickers: [
-        ...new Set(declaredTickers.map((ticker) => ticker.trim()))
-      ].sort()
-    };
-  }
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-  if (activeStrategies.length > 0 && activeStrategies.every((strategy) => strategy.selection?.tickers?.length)) {
-    return {
-      ...deployment,
-      tickers: [
-        ...new Set(
-          activeStrategies.flatMap(
-            (strategy) => strategy.selection?.tickers ?? []
-          )
-        )
-      ].sort()
-    };
-  }
-  const strategiesByName = new Map(
-    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-  );
-  const tickers = /* @__PURE__ */ new Set();
-  for (const scope of lineageScopes) {
-    const strategy = strategiesByName.get(scope.strategy);
-    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !lineageMatchesStrategySnapshot({
-      lineage: scope.lineage,
-      deployment,
-      strategy
-    })) {
-      continue;
-    }
-    tickers.add(scope.symbol.trim());
-  }
-  if (tickers.size === 0) {
-    throw new Error(
-      "Runtime evidence has no immutable ticker universe for the embedded deployment composition"
-    );
-  }
-  return { ...deployment, tickers: [...tickers].sort() };
-};
-var resolveRuntimeEvidenceDeploymentSnapshot = async ({
-  userName,
-  projectRoot: projectRoot2,
-  deploymentId
-}) => {
-  const [deployment, strategies] = await Promise.all([
-    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot: projectRoot2, deploymentId }),
-    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot: projectRoot2, deploymentId })
-  ]);
-  if (!deployment) {
-    throw new Error(`Runtime deployment not found: ${deploymentId}`);
-  }
-  return {
-    schemaVersion: 2,
-    id: deployment.id,
-    deploymentCompositionId: deployment.deploymentCompositionId,
-    label: deployment.label,
-    connectorName: deployment.connectorName,
-    provider: deployment.provider,
-    accountId: deployment.accountId,
-    enabled: deployment.enabled,
-    strategies: strategies.map(
-      ({
-        strategyName,
-        strategyRevision,
-        enabled,
-        controlState,
-        interval,
-        universe,
-        accountId,
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        selection
-      }) => ({
-        strategyName,
-        strategyRevision,
-        enabled,
-        controlState,
-        interval,
-        universe,
-        ...accountId ? { accountId } : {},
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        ...selection ? { selection } : {}
-      })
-    ),
-    ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-    ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-  };
-};
-
 // src/scripts/runtimeEvidence.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -872,20 +980,46 @@ var runtimeEvidence = async () => {
     strategies,
     deploymentId
   });
+  const activeSnapshots = new Map(
+    activeRuntimeEvidenceStrategies(deploymentSnapshot).map((strategy) => [
+      strategy.strategyName,
+      strategy
+    ])
+  );
+  const belongsToCurrentDeployment = (row) => {
+    const snapshot = activeSnapshots.get(row.strategy);
+    return Boolean(
+      snapshot && row.deploymentId === deploymentSnapshot.id && row.accountId === deploymentSnapshot.accountId && runtimeLineageMatchesStrategySnapshot({
+        lineage: row.runtimeLineage,
+        deployment: deploymentSnapshot,
+        strategy: snapshot
+      })
+    );
+  };
+  const currentSignals = evidence.signals.filter(belongsToCurrentDeployment);
+  const currentEvaluations = evidence.evaluations.filter(
+    belongsToCurrentDeployment
+  );
+  const currentTrades = evidence.trades.filter(belongsToCurrentDeployment);
+  const currentLineageScopes = evidence.lineageScopes.filter(
+    (scope) => belongsToCurrentDeployment({
+      ...scope,
+      runtimeLineage: scope.lineage
+    })
+  );
   const runtime = buildRuntimeEvidenceReportPayload({
     userName: flags.user,
     startTime,
     endTime,
-    signals: evidence.signals,
-    evaluations: evidence.evaluations,
-    trades: evidence.trades,
-    strategyConfigs: evidence.strategyConfigs,
+    signals: currentSignals,
+    evaluations: currentEvaluations,
+    trades: currentTrades,
     evaluationStatsBuckets: evidence.evaluationStatsBuckets,
-    lineageScopes: evidence.lineageScopes
+    lineageScopes: currentLineageScopes
   });
   const deployment = resolveRuntimeEvidenceTickerUniverse({
     deployment: deploymentSnapshot,
-    lineageScopes: evidence.lineageScopes
+    lineageScopes: currentLineageScopes
   });
   const artifact = {
     reportType: "runtime-evidence",
@@ -902,13 +1036,13 @@ var runtimeEvidence = async () => {
     deployment,
     runtime
   };
-  const outPath = import_node_path4.default.resolve(projectRoot, String(flags.out));
-  await import_promises4.default.mkdir(import_node_path4.default.dirname(outPath), { recursive: true });
-  await import_promises4.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+  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)}
 `, "utf8");
   const publishDir = String(flags.publishDir ?? "").trim();
   const published = publishDir ? await publishRuntimeEvidenceBundle({
-    publishRoot: import_node_path4.default.resolve(projectRoot, publishDir),
+    publishRoot: import_node_path2.default.resolve(projectRoot, publishDir),
     deploymentId,
     userName: String(flags.user),
     startTime,
@@ -916,12 +1050,10 @@ var runtimeEvidence = async () => {
     artifact,
     counts: artifact.runtime.counts,
     lineageKeys: [
-      ...evidence.signals.map((signal) => signal.runtimeLineage),
-      ...evidence.evaluations.map(
-        (evaluation) => evaluation.runtimeLineage
-      ),
-      ...evidence.trades.map((trade) => trade.runtimeLineage),
-      ...evidence.lineageScopes.map((scope) => scope.lineage)
+      ...currentSignals.map((signal) => signal.runtimeLineage),
+      ...currentEvaluations.map((evaluation) => evaluation.runtimeLineage),
+      ...currentTrades.map((trade) => trade.runtimeLineage),
+      ...currentLineageScopes.map((scope) => scope.lineage)
     ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
   }) : null;
   console.log(import_chalk.default.green(`Wrote ${outPath}`));