@tradejs/cli 3.1.15-beta.228 → 3.1.15

package/dist/lib/runtimeEvidenceSync.js

@@ -31,7 +31,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var runtimeEvidenceSync_exports = {};
 __export(runtimeEvidenceSync_exports, {
   buildRuntimeEvidenceRsyncArgs: () => buildRuntimeEvidenceRsyncArgs,
+  inspectRuntimeEvidenceBundleSupport: () => inspectRuntimeEvidenceBundleSupport,
   listPendingRuntimeEvidenceBundles: () => listPendingRuntimeEvidenceBundles,
+  listRuntimeEvidenceBundleStatuses: () => listRuntimeEvidenceBundleStatuses,
   markRuntimeEvidenceBundleProcessed: () => markRuntimeEvidenceBundleProcessed,
   syncRuntimeEvidenceBundles: () => syncRuntimeEvidenceBundles
 });
@@ -148,6 +150,70 @@ var discoverRuntimeEvidenceBundles = async (rootDir) => {
   return bundles.sort();
 };
 
+// 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/runtimeEvidenceSync.ts
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var isExistingDestinationError = (error) => {
@@ -180,7 +246,26 @@ var buildRuntimeEvidenceRsyncArgs = ({
   withTrailingSlash(destination)
 ];
 var receiptPath = (receiptsRoot, artifactId) => import_node_path2.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
-var listPendingRuntimeEvidenceBundles = async ({
+var compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
+var inspectRuntimeEvidenceBundleSupport = (bundle) => {
+  try {
+    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+      bundle.artifact.deployment
+    );
+    if (activeRuntimeEvidenceStrategies(deployment).length === 0) {
+      throw new Error(
+        "Runtime evidence deployment has no enabled active strategies"
+      );
+    }
+    return { supported: true };
+  } catch (error) {
+    return {
+      supported: false,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+var listRuntimeEvidenceBundleStatuses = async ({
   evidenceRoot,
   deploymentId
 }) => {
@@ -189,19 +274,39 @@ var listPendingRuntimeEvidenceBundles = async ({
   const receiptsRoot = import_node_path2.default.join(evidenceRoot, "receipts", safeDeploymentId);
   const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
   const pending = [];
+  const unsupported = [];
   for (const bundleDir of bundles) {
     const verified = await verifyRuntimeEvidenceBundle(bundleDir);
     if (verified.manifest.deploymentId !== safeDeploymentId) continue;
     try {
       await import_promises2.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+      continue;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
+    }
+    const support = inspectRuntimeEvidenceBundleSupport(verified);
+    if (support.supported) {
       pending.push(verified);
+    } else {
+      unsupported.push({ bundle: verified, reason: support.reason });
     }
   }
-  return pending.sort(
-    (left, right) => left.manifest.window.startTime - right.manifest.window.startTime || left.manifest.createdAt - right.manifest.createdAt
-  );
+  return {
+    pending: pending.sort(compareBundles),
+    unsupported: unsupported.sort(
+      (left, right) => compareBundles(left.bundle, right.bundle)
+    )
+  };
+};
+var listPendingRuntimeEvidenceBundles = async ({
+  evidenceRoot,
+  deploymentId
+}) => {
+  const { pending } = await listRuntimeEvidenceBundleStatuses({
+    evidenceRoot,
+    deploymentId
+  });
+  return pending;
 };
 var markRuntimeEvidenceBundleProcessed = async ({
   evidenceRoot,
@@ -288,21 +393,24 @@ var syncRuntimeEvidenceBundles = async ({
     }
     received.push(await verifyRuntimeEvidenceBundle(destinationDir));
   }
+  const statuses = await listRuntimeEvidenceBundleStatuses({
+    evidenceRoot,
+    deploymentId: safeDeploymentId
+  });
   return {
     rsyncArgs,
     stdout: String(transfer.stdout ?? ""),
     stderr: String(transfer.stderr ?? ""),
     received,
-    pending: await listPendingRuntimeEvidenceBundles({
-      evidenceRoot,
-      deploymentId: safeDeploymentId
-    })
+    ...statuses
   };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildRuntimeEvidenceRsyncArgs,
+  inspectRuntimeEvidenceBundleSupport,
   listPendingRuntimeEvidenceBundles,
+  listRuntimeEvidenceBundleStatuses,
   markRuntimeEvidenceBundleProcessed,
   syncRuntimeEvidenceBundles
 });

package/dist/lib/runtimeScorecard.js

@@ -189,6 +189,138 @@ var buildRuntimeLineageSummary = (rows) => {
     maxLossValue: finiteNumber(identity?.maxLossValue)
   };
 };
+var buildEmbeddedLineageScope = ({
+  artifact,
+  rows,
+  strategy
+}) => {
+  const deployment = asRecord(asRecord(artifact)?.deployment);
+  if (finiteNumber(deployment?.schemaVersion) !== 2) return null;
+  const deploymentId = finiteString(deployment?.id);
+  const accountId = finiteString(deployment?.accountId);
+  const deploymentCompositionId = finiteString(
+    deployment?.deploymentCompositionId
+  );
+  if (!deploymentId || !accountId || !deploymentCompositionId) return null;
+  const snapshots = asArray(deployment?.strategies).map(asRecord).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+    (item) => !strategy || finiteString(item.strategyName) === strategy
+  );
+  const targetSeeds = snapshots.map((snapshot) => {
+    const strategyName = finiteString(snapshot.strategyName);
+    const strategyRevision = finiteString(snapshot.strategyRevision);
+    const strategyPackageVersion = finiteString(
+      snapshot.strategyPackageVersion
+    );
+    const strategyDependencyVersions = packageVersionMap(
+      snapshot.strategyDependencyVersions
+    );
+    const runtimePackageVersion = finiteString(
+      snapshot.runtimePackageVersion
+    );
+    return strategyName && strategyRevision && strategyPackageVersion && strategyDependencyVersions && runtimePackageVersion ? {
+      strategyName,
+      strategyRevision,
+      deploymentCompositionId,
+      strategyPackageVersion,
+      strategyDependencyVersions,
+      runtimePackageVersion
+    } : null;
+  }).filter((item) => item != null);
+  if (targetSeeds.length !== snapshots.length || targetSeeds.length === 0) {
+    return null;
+  }
+  const lineageRows = [
+    ...rows.evaluations,
+    ...rows.signals,
+    ...rows.trades,
+    ...rows.lineageScopes.map((scope) => ({
+      strategy: scope.strategy,
+      deploymentId: scope.deploymentId,
+      accountId: scope.accountId,
+      runtimeLineage: scope.lineage
+    }))
+  ];
+  const identityMatches = (lineage, target) => finiteNumber(lineage?.schemaVersion) === 3 && finiteString(lineage?.strategyRevision) === target.strategyRevision && finiteString(lineage?.deploymentCompositionId) === target.deploymentCompositionId && finiteString(lineage?.strategyPackageVersion) === target.strategyPackageVersion && JSON.stringify(packageVersionMap(lineage?.strategyDependencyVersions)) === JSON.stringify(target.strategyDependencyVersions) && finiteString(lineage?.runtimePackageVersion) === target.runtimePackageVersion;
+  const targets = /* @__PURE__ */ new Map();
+  for (const seed of targetSeeds) {
+    const matchingRows = lineageRows.filter(
+      (row) => finiteString(row.strategy) === seed.strategyName && finiteString(row.deploymentId) === deploymentId && finiteString(row.accountId) === accountId && identityMatches(asRecord(row.runtimeLineage), seed)
+    );
+    const riskValues = new Set(
+      matchingRows.map((row) => finiteNumber(asRecord(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
+    );
+    targets.set(seed.strategyName, {
+      ...seed,
+      maxLossValue: riskValues.size === 1 ? [...riskValues][0] : null,
+      rowsWithLineage: matchingRows.length,
+      riskConflict: riskValues.size > 1
+    });
+  }
+  const belongs = (row) => {
+    const strategyName = finiteString(row.strategy);
+    const target = strategyName ? targets.get(strategyName) : null;
+    const lineage = asRecord(row.runtimeLineage);
+    return Boolean(
+      target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber(lineage?.maxLossValue) === target.maxLossValue
+    );
+  };
+  const targetValues = [...targets.values()];
+  const coverageComplete = targetValues.every(
+    (target) => target.rowsWithLineage > 0 && target.maxLossValue != null
+  );
+  const commonRiskValues = new Set(
+    targetValues.map((target) => target.maxLossValue).filter((value) => value != null)
+  );
+  const singleTarget = targetValues.length === 1 ? targetValues[0] : null;
+  const singleLineage = singleTarget?.maxLossValue != null ? {
+    schemaVersion: 3,
+    strategyRevision: singleTarget.strategyRevision,
+    deploymentCompositionId: singleTarget.deploymentCompositionId,
+    strategyPackageVersion: singleTarget.strategyPackageVersion,
+    strategyDependencyVersions: singleTarget.strategyDependencyVersions,
+    runtimePackageVersion: singleTarget.runtimePackageVersion,
+    maxLossValue: singleTarget.maxLossValue
+  } : null;
+  return {
+    belongs,
+    summary: {
+      complete: coverageComplete,
+      identityComplete: true,
+      coverageComplete,
+      conflicts: targetValues.some((target) => target.riskConflict),
+      rows: lineageRows.length,
+      rowsWithLineage: targetValues.reduce(
+        (total, target) => total + target.rowsWithLineage,
+        0
+      ),
+      schemaVersion: 3,
+      lineageKey: singleLineage ? runtimeLineageKey(singleLineage) : null,
+      strategyRevision: singleTarget?.strategyRevision ?? null,
+      deploymentCompositionId,
+      strategyPackageVersion: singleTarget?.strategyPackageVersion ?? null,
+      strategyDependencyVersions: singleTarget?.strategyDependencyVersions ?? null,
+      runtimePackageVersion: singleTarget?.runtimePackageVersion ?? null,
+      compositionId: null,
+      gitSha: null,
+      gitDirty: null,
+      gateFingerprint: null,
+      configFingerprint: null,
+      contextFingerprint: null,
+      maxLossValue: commonRiskValues.size === 1 ? [...commonRiskValues][0] : null,
+      strategyScopes: Object.fromEntries(
+        targetValues.map((target) => [
+          target.strategyName,
+          {
+            strategyRevision: target.strategyRevision,
+            rowsWithLineage: target.rowsWithLineage,
+            maxLossValue: target.maxLossValue,
+            complete: target.rowsWithLineage > 0 && target.maxLossValue != null
+          }
+        ])
+      )
+    }
+  };
+};
 var belongsToRuntimeLineage = (row, summary) => {
   if (!summary.identityComplete || !summary.lineageKey) return false;
   const lineage = asRecord(row.runtimeLineage);
@@ -414,7 +546,12 @@ var buildRuntimeScorecard = ({
   );
   const deploymentBinding = runtimeDeploymentBinding(runtimeArtifact);
   const rows = extractRuntimeRows(scopedRuntimeArtifact);
-  const runtimeLineage = buildRuntimeLineageSummary(rows);
+  const embeddedLineageScope = buildEmbeddedLineageScope({
+    artifact: runtimeArtifact,
+    rows,
+    strategy
+  });
+  const runtimeLineage = embeddedLineageScope?.summary ?? buildRuntimeLineageSummary(rows);
   const window = runtimeWindow(runtimeArtifact);
   const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
   const endTime = finiteNumber(window.endTime) ?? generatedAt;
@@ -463,12 +600,17 @@ var buildRuntimeScorecard = ({
   const lineageReason = finiteString(lineage?.reason);
   const calibrationRoot = asRecord(calibrationArtifact) ?? {};
   const calibrationSummary = asRecord(calibrationRoot.summary);
-  const calibration = strategy ? asRecord(asRecord(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
-  const actualSlippageBps = finiteNumber(
-    asRecord(calibration?.signalToFillAdverseBps)?.avg
+  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter(
+    (item) => !embeddedLineageScope || embeddedLineageScope.belongs(item)
   );
-  const residualVsModelBps = finiteNumber(
-    asRecord(calibration?.residualVsCurrentModelBps)?.avg
+  const averageSampleMetric = (field) => {
+    const values = calibrationSamples.map((sample) => finiteNumber(sample[field])).filter((value) => value != null);
+    return values.length ? round(sum(values) / values.length) : null;
+  };
+  const fallbackCalibration = strategy ? asRecord(asRecord(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
+  const actualSlippageBps = embeddedLineageScope ? averageSampleMetric("signalToFillAdverseBps") : finiteNumber(asRecord(fallbackCalibration?.signalToFillAdverseBps)?.avg);
+  const residualVsModelBps = embeddedLineageScope ? averageSampleMetric("residualVsCurrentModelBps") : finiteNumber(
+    asRecord(fallbackCalibration?.residualVsCurrentModelBps)?.avg
   );
   const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
   const historyTrades = dedupeTrades([
@@ -476,10 +618,13 @@ var buildRuntimeScorecard = ({
     scopedRuntimeArtifact
   ]);
   const comparableHistoryTrades = historyTrades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && belongsToRuntimeLineage(trade, runtimeLineage)
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
   );
   const comparableCurrentClosedTrades = currentClosedTrades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && belongsToRuntimeLineage(trade, runtimeLineage)
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+  );
+  const comparableFills = rows.trades.filter(
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
   );
   const currentDistributions = buildDistributions(rows);
   const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
@@ -593,7 +738,8 @@ var buildRuntimeScorecard = ({
           `${finiteString(signal.orderSkipReason) ?? ""} ${finiteString(signal.orderFailureReason) ?? ""}`
         )
       ).length,
-      fills: rows.trades.length,
+      fills: comparableFills.length,
+      nonComparableFills: rows.trades.length - comparableFills.length,
       closedTrades: currentClosedTrades.length,
       comparableClosedTrades: comparableCurrentClosedTrades.length,
       nonComparableClosedTrades: currentClosedTrades.length - comparableCurrentClosedTrades.length
@@ -642,7 +788,7 @@ var buildRuntimeScorecard = ({
       lineageReason
     },
     execution: {
-      available: calibration != null,
+      available: actualSlippageBps != null || residualVsModelBps != null,
       actualSignalToFillSlippageBps: actualSlippageBps,
       residualVsCurrentModelBps: residualVsModelBps
     },

package/dist/scripts/replay.js

@@ -4706,6 +4706,24 @@ var INTERVALS = /* @__PURE__ */ new Set([
 ]);
 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 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 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(
@@ -4745,6 +4763,54 @@ var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
   };
 };
 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 runtimeDeploymentFromEvidence = (deployment) => ({
   id: deployment.id,
   deploymentCompositionId: deployment.deploymentCompositionId,
@@ -4812,7 +4878,13 @@ var readRuntimeEvidenceArtifact = async ({
     userName: String(root.userName ?? runtime.userName ?? "").trim(),
     startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime),
     endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime),
-    deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment)
+    deployment: resolveRuntimeEvidenceTickerUniverse({
+      deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment),
+      lineageScopes: unwrapRows(
+        runtime.lineageScopes,
+        "lineageScope"
+      )
+    })
   };
 };
 var loadReplayRuntimeEvidenceMetadata = async (params) => {
@@ -7735,7 +7807,7 @@ var filterReplayComparisonByLineage = ({
       excludedRuntimeLineageScopes: runtimeLineageScopes.length - comparableRuntimeLineageScopes.length,
       excludedExchangeEntries: 0,
       excludedBacktestEntries: backtestEntries.length - comparableBacktestEntries.length,
-      reason: comparableScopeKeys.size > 0 ? null : "no_runtime_artifacts_with_matching_lineage",
+      reason: comparableScopeKeys.size > 0 ? null : expectedByScope.size === 0 ? "replay_produced_no_lineage_scopes" : "no_runtime_artifacts_with_matching_lineage",
       replay: [...expectedByScope.entries()].map(([scope, lineage]) => {
         const [deploymentId, accountId, strategy, symbol] = scope.split("::");
         return {

package/dist/scripts/replayRunner.js

@@ -4709,6 +4709,24 @@ var INTERVALS = /* @__PURE__ */ new Set([
 ]);
 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 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 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(
@@ -4748,6 +4766,54 @@ var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
   };
 };
 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 runtimeDeploymentFromEvidence = (deployment) => ({
   id: deployment.id,
   deploymentCompositionId: deployment.deploymentCompositionId,
@@ -4815,7 +4881,13 @@ var readRuntimeEvidenceArtifact = async ({
     userName: String(root.userName ?? runtime.userName ?? "").trim(),
     startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime),
     endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime),
-    deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment)
+    deployment: resolveRuntimeEvidenceTickerUniverse({
+      deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment),
+      lineageScopes: unwrapRows(
+        runtime.lineageScopes,
+        "lineageScope"
+      )
+    })
   };
 };
 var loadReplayRuntimeEvidenceMetadata = async (params) => {
@@ -7738,7 +7810,7 @@ var filterReplayComparisonByLineage = ({
       excludedRuntimeLineageScopes: runtimeLineageScopes.length - comparableRuntimeLineageScopes.length,
       excludedExchangeEntries: 0,
       excludedBacktestEntries: backtestEntries.length - comparableBacktestEntries.length,
-      reason: comparableScopeKeys.size > 0 ? null : "no_runtime_artifacts_with_matching_lineage",
+      reason: comparableScopeKeys.size > 0 ? null : expectedByScope.size === 0 ? "replay_produced_no_lineage_scopes" : "no_runtime_artifacts_with_matching_lineage",
       replay: [...expectedByScope.entries()].map(([scope, lineage]) => {
         const [deploymentId, accountId, strategy, symbol] = scope.split("::");
         return {