@tradejs/cli 3.1.15-beta.228 → 3.1.15

package/dist/cli.js

@@ -25611,7 +25611,7 @@ var init_runtimeLineage = __esm({
 });
 
 // src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies3, isRecord, isNonEmptyString, isPackageVersionMap, INTERVALS, UNIVERSES, isRuntimeStrategySelection, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
+var import_runtimeStrategies3, isRecord, isNonEmptyString, isPackageVersionMap, INTERVALS, UNIVERSES, isRuntimeStrategySelection, samePackageVersions, lineageMatchesStrategySnapshot, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, resolveRuntimeEvidenceTickerUniverse, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
 var init_runtimeEvidenceDeployment = __esm({
   "src/lib/runtimeEvidenceDeployment.ts"() {
     "use strict";
@@ -25638,6 +25638,24 @@ var init_runtimeEvidenceDeployment = __esm({
     ]);
     UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
     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));
+    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);
+    };
+    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
+    );
     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(
@@ -25677,6 +25695,54 @@ var init_runtimeEvidenceDeployment = __esm({
       };
     };
     activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+    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() };
+    };
     runtimeDeploymentFromEvidence = (deployment) => ({
       id: deployment.id,
       deploymentCompositionId: deployment.deploymentCompositionId,
@@ -25853,18 +25919,18 @@ var init_runtimeEvidence = __esm({
     runtimeEvidence = async () => {
       const { startTime, endTime, source } = resolveWindow2();
       const deploymentId = String(flags25.deployment);
-      const deployment = await resolveRuntimeEvidenceDeploymentSnapshot({
+      const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
         userName: String(flags25.user),
         projectRoot: projectRoot9,
         deploymentId
       });
-      const activeStrategies = activeRuntimeEvidenceStrategies(deployment).map(
-        ({ strategyName }) => strategyName
-      );
+      const activeStrategies = activeRuntimeEvidenceStrategies(
+        deploymentSnapshot
+      ).map(({ strategyName }) => strategyName);
       const requestedStrategies = parseStrategyFilter2(flags25.strategy);
       const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
       const declaredStrategies = new Set(
-        deployment.strategies.map(({ strategyName }) => strategyName)
+        deploymentSnapshot.strategies.map(({ strategyName }) => strategyName)
       );
       const unknownStrategies = strategies.filter(
         (strategyName) => !declaredStrategies.has(strategyName)
@@ -25892,6 +25958,10 @@ var init_runtimeEvidence = __esm({
         evaluationStatsBuckets: evidence.evaluationStatsBuckets,
         lineageScopes: evidence.lineageScopes
       });
+      const deployment = resolveRuntimeEvidenceTickerUniverse({
+        deployment: deploymentSnapshot,
+        lineageScopes: evidence.lineageScopes
+      });
       const artifact = {
         reportType: "runtime-evidence",
         generatedAt: Date.now(),
@@ -25949,7 +26019,7 @@ var init_runtimeEvidence = __esm({
 });
 
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process7, import_promises25, import_node_path19, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment2, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process7, import_promises25, import_node_path19, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment2, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, inspectRuntimeEvidenceBundleSupport, listRuntimeEvidenceBundleStatuses, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
@@ -25958,6 +26028,7 @@ var init_runtimeEvidenceSync = __esm({
     import_node_path19 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceDeployment();
     execFileAsync = (0, import_node_util.promisify)(import_node_child_process7.execFile);
     isExistingDestinationError2 = (error) => {
       const code = error.code;
@@ -25989,7 +26060,26 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(destination)
     ];
     receiptPath = (receiptsRoot, artifactId) => import_node_path19.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
-    listPendingRuntimeEvidenceBundles = async ({
+    compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
+    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)
+        };
+      }
+    };
+    listRuntimeEvidenceBundleStatuses = async ({
       evidenceRoot,
       deploymentId
     }) => {
@@ -25998,19 +26088,29 @@ var init_runtimeEvidenceSync = __esm({
       const receiptsRoot = import_node_path19.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_promises25.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)
+        )
+      };
     };
     markRuntimeEvidenceBundleProcessed = async ({
       evidenceRoot,
@@ -26097,15 +26197,16 @@ var init_runtimeEvidenceSync = __esm({
         }
         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
       };
     };
   }
@@ -26157,7 +26258,7 @@ var init_runtimeEvidenceSync2 = __esm({
       });
       console.log(
         import_chalk40.default.green(
-          `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length}`
+          `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length} unsupported=${result.unsupported.length}`
         )
       );
       console.log(
@@ -26174,6 +26275,13 @@ var init_runtimeEvidenceSync2 = __esm({
               bundleDir: bundle.bundleDir,
               payloadPath: bundle.payloadPath,
               window: bundle.manifest.window
+            })),
+            unsupported: result.unsupported.map(({ bundle, reason }) => ({
+              artifactId: bundle.manifest.artifactId,
+              bundleDir: bundle.bundleDir,
+              payloadPath: bundle.payloadPath,
+              window: bundle.manifest.window,
+              reason
             }))
           },
           null,
@@ -26186,7 +26294,7 @@ var init_runtimeEvidenceSync2 = __esm({
 });
 
 // src/lib/runtimeScorecard.ts
-var asRecord6, asArray3, finiteNumber5, finiteString2, packageVersionMap, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildRuntimeLineageSummary, belongsToRuntimeLineage, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, buildDistributions, buildDistributionDelta, sum2, statsCount, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getCalibrationSummary, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
+var asRecord6, asArray3, finiteNumber5, finiteString2, packageVersionMap, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildRuntimeLineageSummary, buildEmbeddedLineageScope, belongsToRuntimeLineage, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, buildDistributions, buildDistributionDelta, sum2, statsCount, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getCalibrationSummary, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
 var init_runtimeScorecard = __esm({
   "src/lib/runtimeScorecard.ts"() {
     "use strict";
@@ -26297,6 +26405,138 @@ var init_runtimeScorecard = __esm({
         maxLossValue: finiteNumber5(identity?.maxLossValue)
       };
     };
+    buildEmbeddedLineageScope = ({
+      artifact,
+      rows,
+      strategy
+    }) => {
+      const deployment = asRecord6(asRecord6(artifact)?.deployment);
+      if (finiteNumber5(deployment?.schemaVersion) !== 2) return null;
+      const deploymentId = finiteString2(deployment?.id);
+      const accountId = finiteString2(deployment?.accountId);
+      const deploymentCompositionId = finiteString2(
+        deployment?.deploymentCompositionId
+      );
+      if (!deploymentId || !accountId || !deploymentCompositionId) return null;
+      const snapshots = asArray3(deployment?.strategies).map(asRecord6).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+        (item) => !strategy || finiteString2(item.strategyName) === strategy
+      );
+      const targetSeeds = snapshots.map((snapshot) => {
+        const strategyName = finiteString2(snapshot.strategyName);
+        const strategyRevision = finiteString2(snapshot.strategyRevision);
+        const strategyPackageVersion = finiteString2(
+          snapshot.strategyPackageVersion
+        );
+        const strategyDependencyVersions = packageVersionMap(
+          snapshot.strategyDependencyVersions
+        );
+        const runtimePackageVersion = finiteString2(
+          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) => finiteNumber5(lineage?.schemaVersion) === 3 && finiteString2(lineage?.strategyRevision) === target.strategyRevision && finiteString2(lineage?.deploymentCompositionId) === target.deploymentCompositionId && finiteString2(lineage?.strategyPackageVersion) === target.strategyPackageVersion && JSON.stringify(packageVersionMap(lineage?.strategyDependencyVersions)) === JSON.stringify(target.strategyDependencyVersions) && finiteString2(lineage?.runtimePackageVersion) === target.runtimePackageVersion;
+      const targets = /* @__PURE__ */ new Map();
+      for (const seed of targetSeeds) {
+        const matchingRows = lineageRows.filter(
+          (row) => finiteString2(row.strategy) === seed.strategyName && finiteString2(row.deploymentId) === deploymentId && finiteString2(row.accountId) === accountId && identityMatches(asRecord6(row.runtimeLineage), seed)
+        );
+        const riskValues = new Set(
+          matchingRows.map((row) => finiteNumber5(asRecord6(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 = finiteString2(row.strategy);
+        const target = strategyName ? targets.get(strategyName) : null;
+        const lineage = asRecord6(row.runtimeLineage);
+        return Boolean(
+          target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber5(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
+              }
+            ])
+          )
+        }
+      };
+    };
     belongsToRuntimeLineage = (row, summary) => {
       if (!summary.identityComplete || !summary.lineageKey) return false;
       const lineage = asRecord6(row.runtimeLineage);
@@ -26522,7 +26762,12 @@ var init_runtimeScorecard = __esm({
       );
       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 = finiteNumber5(window.startTime) ?? generatedAt - 864e5;
       const endTime = finiteNumber5(window.endTime) ?? generatedAt;
@@ -26571,12 +26816,17 @@ var init_runtimeScorecard = __esm({
       const lineageReason = finiteString2(lineage?.reason);
       const calibrationRoot = asRecord6(calibrationArtifact) ?? {};
       const calibrationSummary = asRecord6(calibrationRoot.summary);
-      const calibration = strategy ? asRecord6(asRecord6(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
-      const actualSlippageBps = finiteNumber5(
-        asRecord6(calibration?.signalToFillAdverseBps)?.avg
+      const calibrationSamples = asArray3(calibrationRoot.samples).map(asRecord6).filter((item) => item != null).filter((item) => !strategy || finiteString2(item.strategy) === strategy).filter(
+        (item) => !embeddedLineageScope || embeddedLineageScope.belongs(item)
       );
-      const residualVsModelBps = finiteNumber5(
-        asRecord6(calibration?.residualVsCurrentModelBps)?.avg
+      const averageSampleMetric = (field) => {
+        const values = calibrationSamples.map((sample) => finiteNumber5(sample[field])).filter((value) => value != null);
+        return values.length ? round(sum2(values) / values.length) : null;
+      };
+      const fallbackCalibration = strategy ? asRecord6(asRecord6(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
+      const actualSlippageBps = embeddedLineageScope ? averageSampleMetric("signalToFillAdverseBps") : finiteNumber5(asRecord6(fallbackCalibration?.signalToFillAdverseBps)?.avg);
+      const residualVsModelBps = embeddedLineageScope ? averageSampleMetric("residualVsCurrentModelBps") : finiteNumber5(
+        asRecord6(fallbackCalibration?.residualVsCurrentModelBps)?.avg
       );
       const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
       const historyTrades = dedupeTrades([
@@ -26584,10 +26834,13 @@ var init_runtimeScorecard = __esm({
         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 }) => {
@@ -26701,7 +26954,8 @@ var init_runtimeScorecard = __esm({
               `${finiteString2(signal.orderSkipReason) ?? ""} ${finiteString2(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
@@ -26750,7 +27004,7 @@ var init_runtimeScorecard = __esm({
           lineageReason
         },
         execution: {
-          available: calibration != null,
+          available: actualSlippageBps != null || residualVsModelBps != null,
           actualSignalToFillSlippageBps: actualSlippageBps,
           residualVsCurrentModelBps: residualVsModelBps
         },
@@ -33573,7 +33827,13 @@ var init_runtimeEvidenceSource = __esm({
         userName: String(root.userName ?? runtime.userName ?? "").trim(),
         startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow2?.startTime),
         endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow2?.endTime),
-        deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment)
+        deployment: resolveRuntimeEvidenceTickerUniverse({
+          deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment),
+          lineageScopes: unwrapRows2(
+            runtime.lineageScopes,
+            "lineageScope"
+          )
+        })
       };
     };
     loadReplayRuntimeEvidenceMetadata = async (params) => {
@@ -35969,7 +36229,7 @@ var init_runtimeComparison = __esm({
           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/lib/runtimeEvidenceDeployment.js

@@ -23,6 +23,7 @@ __export(runtimeEvidenceDeployment_exports, {
   activeRuntimeEvidenceStrategies: () => activeRuntimeEvidenceStrategies,
   parseRuntimeEvidenceDeploymentSnapshot: () => parseRuntimeEvidenceDeploymentSnapshot,
   resolveRuntimeEvidenceDeploymentSnapshot: () => resolveRuntimeEvidenceDeploymentSnapshot,
+  resolveRuntimeEvidenceTickerUniverse: () => resolveRuntimeEvidenceTickerUniverse,
   runtimeDeploymentFromEvidence: () => runtimeDeploymentFromEvidence
 });
 module.exports = __toCommonJS(runtimeEvidenceDeployment_exports);
@@ -49,6 +50,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(
@@ -88,6 +107,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,
@@ -169,5 +236,6 @@ var resolveRuntimeEvidenceDeploymentSnapshot = async ({
   activeRuntimeEvidenceStrategies,
   parseRuntimeEvidenceDeploymentSnapshot,
   resolveRuntimeEvidenceDeploymentSnapshot,
+  resolveRuntimeEvidenceTickerUniverse,
   runtimeDeploymentFromEvidence
 });