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

package/dist/cli.js

@@ -2185,9 +2185,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path36) => (Array.isArray(path36) ? path36 : path36.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path36) => {
-      const segments = normalizeFeaturePath(path36);
+    normalizeFeaturePath = (path35) => (Array.isArray(path35) ? path35 : path35.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path35) => {
+      const segments = normalizeFeaturePath(path35);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2361,8 +2361,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path36) => {
-      const segments = (Array.isArray(path36) ? path36 : path36.split(".")).filter(
+    classifyAiPocketFeaturePath = (path35) => {
+      const segments = (Array.isArray(path35) ? path35 : path35.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -10693,27 +10693,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path36) => {
-      if (path36.includes("global-metrics")) return "global";
-      if (path36.includes("cryptocurrency/quotes")) return "reference";
-      if (path36.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path36.includes("fear-and-greed")) return "fearGreed";
-      if (path36.includes("cmc100")) return "cmc100";
-      if (path36.includes("cmc20")) return "cmc20";
-      return path36;
-    };
-    recordCoinMarketCapFetchStats = (stats, path36, creditCount) => {
+    getCoinMarketCapPathLabel = (path35) => {
+      if (path35.includes("global-metrics")) return "global";
+      if (path35.includes("cryptocurrency/quotes")) return "reference";
+      if (path35.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path35.includes("fear-and-greed")) return "fearGreed";
+      if (path35.includes("cmc100")) return "cmc100";
+      if (path35.includes("cmc20")) return "cmc20";
+      return path35;
+    };
+    recordCoinMarketCapFetchStats = (stats, path35, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path36) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path35) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path36, existing);
+      stats.byPath.set(path35, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path36, item]) => `${getCoinMarketCapPathLabel(path36)}=${item.requests}req/${item.credits}cr`
+        ([path35, item]) => `${getCoinMarketCapPathLabel(path35)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -12235,9 +12235,7 @@ var init_runtimeRedis = __esm({
           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_redis4.redisKeys.runtimeTrades(userName3);
       const bucketPrefix = import_redis4.redisKeys.runtimeTradeBuckets(userName3);
@@ -24348,16 +24346,14 @@ var init_runtimeDebugEvidence = __esm({
         signals2,
         evaluations,
         evaluationStatsBuckets,
-        lineageScopes,
-        configs
+        lineageScopes
       ] = await Promise.all([
         loadRuntimeTrades(userName3, { startTime, endTime }),
         loadRuntimeClosedTrades(userName3, { startTime, endTime }),
         loadRuntimeSignals(userName3, { startTime, endTime }),
         loadRuntimeSignalEvaluations(userName3, { startTime, endTime }),
         loadRuntimeSignalEvaluationStatsBuckets(userName3),
-        loadRuntimeLineageScopes(userName3, { startTime, endTime }),
-        (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName3)
+        loadRuntimeLineageScopes(userName3, { startTime, endTime })
       ]);
       const tradesByOrderId = new Map(
         entryTrades.map((trade) => [trade.orderId, trade])
@@ -24382,9 +24378,6 @@ var init_runtimeDebugEvidence = __esm({
         evaluationStatsBuckets: filteredStats,
         lineageScopes: lineageScopes.filter(matchesDeployment).filter(
           (scope) => !strategies?.length || strategies.includes(scope.strategy)
-        ),
-        strategyConfigs: deploymentId ? [] : configs.filter(
-          (config2) => !strategies?.length || strategies.includes(config2.strategyName)
         )
       };
     };
@@ -24395,7 +24388,6 @@ var init_runtimeDebugEvidence = __esm({
       signals: signals2,
       evaluations,
       trades,
-      strategyConfigs,
       evaluationStatsBuckets,
       lineageScopes
     }) => {
@@ -24525,8 +24517,7 @@ var init_runtimeDebugEvidence = __esm({
           signals: signals2.length,
           evaluations: reportEvaluations.length,
           evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
-          lineageScopes: lineageScopes?.length ?? 0,
-          strategyConfigs: strategyConfigs?.length ?? 0
+          lineageScopes: lineageScopes?.length ?? 0
         },
         trades: debugTrades,
         signals: signals2.map((signal) => ({
@@ -24549,8 +24540,7 @@ var init_runtimeDebugEvidence = __esm({
           evaluation
         })),
         evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-        lineageScopes: lineageScopes ?? [],
-        strategyConfigs: strategyConfigs ?? []
+        lineageScopes: lineageScopes ?? []
       };
     };
     buildRuntimeEvidenceReportPayload = ({
@@ -24560,7 +24550,6 @@ var init_runtimeDebugEvidence = __esm({
       signals: signals2,
       evaluations,
       trades,
-      strategyConfigs,
       evaluationStatsBuckets,
       lineageScopes
     }) => ({
@@ -24579,15 +24568,13 @@ var init_runtimeDebugEvidence = __esm({
         signals: signals2.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: signals2.map((signal) => ({ signal })),
       evaluations: evaluations.map((evaluation) => ({ evaluation })),
       evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-      lineageScopes: lineageScopes ?? [],
-      strategyConfigs: strategyConfigs ?? []
+      lineageScopes: lineageScopes ?? []
     });
     buildRuntimeDebugReportAttachment = async (params) => {
       const payload = await buildRuntimeDebugReportPayload(params);
@@ -25017,7 +25004,6 @@ var init_replayRuntimeEvidence = __esm({
           signals: runtimeEvidence2.signals,
           evaluations: runtimeEvidence2.evaluations,
           trades: runtimeEvidence2.trades,
-          strategyConfigs: runtimeEvidence2.strategyConfigs,
           evaluationStatsBuckets: runtimeEvidence2.evaluationStatsBuckets,
           lineageScopes: runtimeEvidence2.lineageScopes
         })
@@ -25099,6 +25085,294 @@ var init_replayRuntimeEvidence = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies3, isRecord, isNonEmptyString, isPackageVersionMap, INTERVALS, UNIVERSES, isRuntimeStrategySelection, samePackageVersions, runtimeLineageMatchesStrategySnapshot, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, unwrapRuntimeEvidenceRows, assertCurrentRuntimeEvidenceArtifact, resolveRuntimeEvidenceTickerUniverse, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
+var init_runtimeEvidenceDeployment = __esm({
+  "src/lib/runtimeEvidenceDeployment.ts"() {
+    "use strict";
+    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
+    isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+    isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
+      ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
+    );
+    INTERVALS = /* @__PURE__ */ new Set([
+      "1",
+      "3",
+      "5",
+      "15",
+      "30",
+      "60",
+      "120",
+      "240",
+      "360",
+      "720",
+      "D",
+      "W",
+      "M"
+    ]);
+    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);
+    };
+    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
+    );
+    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
+      };
+    };
+    activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+    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);
+    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;
+    };
+    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() };
+    };
+    runtimeDeploymentFromEvidence = (deployment) => ({
+      id: deployment.id,
+      deploymentCompositionId: deployment.deploymentCompositionId,
+      label: deployment.label,
+      connectorName: deployment.connectorName,
+      provider: deployment.provider,
+      accountId: deployment.accountId,
+      enabled: deployment.enabled,
+      strategies: deployment.strategies.map(
+        ({ strategyName, strategyRevision, enabled, controlState, selection }) => ({
+          strategyName,
+          strategyRevision,
+          enabled,
+          controlState,
+          ...selection ? { selection } : {}
+        })
+      ),
+      ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+      ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+    });
+    resolveRuntimeEvidenceDeploymentSnapshot = async ({
+      userName: userName3,
+      projectRoot: projectRoot15,
+      deploymentId
+    }) => {
+      const [deployment, strategies] = await Promise.all([
+        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot15, deploymentId }),
+        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot15, 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: interval4,
+            universe,
+            accountId,
+            strategyPackage,
+            strategyPackageVersion,
+            strategyDependencyVersions,
+            runtimePackageVersion,
+            strategyConfig,
+            selection
+          }) => ({
+            strategyName,
+            strategyRevision,
+            enabled,
+            controlState,
+            interval: interval4,
+            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 import_node_crypto10, import_promises22, import_node_path16, RUNTIME_EVIDENCE_MANIFEST_FILE, RUNTIME_EVIDENCE_PAYLOAD_FILE, RUNTIME_EVIDENCE_COMPLETE_FILE, asRecord5, sha256, runtimeEvidenceIdentitySha256, isExistingDestinationError, safeSegment, compactTimestamp, dateParts, assertFiniteTimestamp, parseManifest, publishRuntimeEvidenceBundle, verifyRuntimeEvidenceBundle, discoverRuntimeEvidenceBundles;
 var init_runtimeEvidenceArtifacts = __esm({
@@ -25107,6 +25381,7 @@ var init_runtimeEvidenceArtifacts = __esm({
     import_node_crypto10 = require("crypto");
     import_promises22 = __toESM(require("fs/promises"));
     import_node_path16 = __toESM(require("path"));
+    init_runtimeEvidenceDeployment();
     RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
     RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
     RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
@@ -25190,6 +25465,7 @@ var init_runtimeEvidenceArtifacts = __esm({
       counts,
       lineageKeys
     }) => {
+      assertCurrentRuntimeEvidenceArtifact(artifact);
       const payload = `${JSON.stringify(artifact, null, 2)}
 `;
       const payloadSha256 = sha256(payload);
@@ -25289,6 +25565,10 @@ var init_runtimeEvidenceArtifacts = __esm({
       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,
@@ -25326,131 +25606,11 @@ var init_runtimeEvidenceArtifacts = __esm({
 });
 
 // src/lib/runtimeLineage.ts
-async function buildRuntimeLineage({
-  projectRoot: projectRoot15,
-  strategyName,
-  compositionId,
-  strategyRevision,
-  deploymentCompositionId,
-  strategyPackageVersion,
-  strategyDependencyVersions,
-  runtimePackageVersion,
-  config: config2,
-  runContext,
-  env = process.env
-}) {
-  if (strategyRevision != null) {
-    if (!/^sr1:[a-f0-9]{16}$/.test(strategyRevision)) {
-      throw new Error(`Invalid strategy revision: ${strategyRevision}`);
-    }
-    if (typeof deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(deploymentCompositionId)) {
-      throw new Error(
-        `Invalid deployment composition id: ${String(deploymentCompositionId)}`
-      );
-    }
-    if (typeof strategyPackageVersion !== "string" || !strategyPackageVersion.trim() || typeof runtimePackageVersion !== "string" || !runtimePackageVersion.trim()) {
-      throw new Error("Invalid revision package versions");
-    }
-    if (!strategyDependencyVersions || Object.keys(strategyDependencyVersions).length === 0 || Object.entries(strategyDependencyVersions).some(
-      ([name, version]) => !name.startsWith("@tradejs/") || typeof version !== "string" || !version.trim()
-    )) {
-      throw new Error("Invalid strategy dependency versions");
-    }
-    return {
-      schemaVersion: 3,
-      strategyRevision,
-      deploymentCompositionId,
-      strategyPackageVersion,
-      strategyDependencyVersions,
-      runtimePackageVersion,
-      maxLossValue: resolveRuntimeMaxLossValue(config2)
-    };
-  }
-  const git = resolveGitLineage(projectRoot15);
-  const hyperliquidPerpUniverseFingerprint = typeof import_strategies10.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies10.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
-    projectRoot15,
-    "packages/node/src/config/hyperliquidPerpUniverse.json"
-  );
-  const hyperliquidWhaleRegistryFingerprint = typeof import_strategies10.getHyperliquidWhaleRegistrySnapshot === "function" ? (0, import_strategies10.getHyperliquidWhaleRegistrySnapshot)().fingerprint : await resolveSnapshotFingerprint(
-    projectRoot15,
-    "packages/node/src/config/hyperliquidWhales.json"
-  );
-  const context = {
-    ...Object.fromEntries(
-      RUNTIME_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
-    ),
-    ...RUNTIME_CONTEXT_DATA_MODEL,
-    binanceBreadthUniverseFingerprint: await resolveBinanceBreadthFingerprint(projectRoot15),
-    hyperliquidPerpUniverseFingerprint,
-    hyperliquidWhaleRegistryFingerprint,
-    ...runContext
-  };
-  return {
-    schemaVersion: 1,
-    compositionId: compositionId?.trim() || null,
-    ...git,
-    gateFingerprint: (await resolveRuntimeGateFingerprint({
-      projectRoot: projectRoot15,
-      strategyName,
-      gitSha: git.gitSha
-    })).gateFingerprint,
-    // Position risk is tracked separately so changing trade size does not
-    // masquerade as a change to the core + gate decision logic.
-    configFingerprint: (0, import_strategyReleaseEvidence2.strategyLogicConfigFingerprint)(config2),
-    contextFingerprint: fingerprintRuntimeValue(context),
-    maxLossValue: resolveRuntimeMaxLossValue(config2)
-  };
-}
-var import_node_child_process6, import_node_crypto11, import_promises23, import_node_path17, import_types8, import_strategies10, import_strategyReleaseEvidence2, RUNTIME_CONTEXT_ENV_KEYS, RUNTIME_CONTEXT_DATA_MODEL, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, gitLineageCache, gateFingerprintCache, binanceBreadthFingerprintCache, snapshotFingerprintCache, resolveGitLineage, readOptionalFile, resolveBinanceBreadthFingerprint, resolveSnapshotFingerprint, resolveRuntimeGateFingerprint, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
+var import_node_crypto11, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, buildRuntimeLineage, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
 var init_runtimeLineage = __esm({
   "src/lib/runtimeLineage.ts"() {
     "use strict";
-    import_node_child_process6 = require("child_process");
     import_node_crypto11 = require("crypto");
-    import_promises23 = __toESM(require("fs/promises"));
-    import_node_path17 = __toESM(require("path"));
-    import_types8 = require("@tradejs/types");
-    import_strategies10 = require("@tradejs/node/strategies");
-    import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
-    init_strategyGateFingerprint();
-    RUNTIME_CONTEXT_ENV_KEYS = [
-      "AI_MODE",
-      "MIN_AI_QUALITY",
-      "INTERVAL",
-      "DERIVATIVES_CONTEXT_ENABLED",
-      "DERIVATIVES_CONTEXT_TARGET_ENABLED",
-      "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
-      "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
-      "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
-      "COINMARKETCAP_CONTEXT_ENABLED",
-      "COINMARKETCAP_CONTEXT_MAX_AGE_MS",
-      "COINMARKETCAP_CONTEXT_EXCHANGE_LIQUIDITY_ENABLED",
-      "COINMARKETCAP_CONTEXT_EXCHANGE_SLUGS",
-      "COINMARKETCAP_CONTEXT_FEAR_GREED_ENABLED",
-      "COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS",
-      "COINMARKETCAP_CONTEXT_BACKFILL_ENABLED",
-      "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
-      "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS",
-      "HYPERLIQUID_WHALE_CONTEXT_ENABLED",
-      "HYPERLIQUID_WHALE_BACKFILL_ENABLED",
-      "HYPERLIQUID_WHALE_MIN_COVERAGE_PCT",
-      "HYPERLIQUID_WHALE_CONCURRENCY",
-      "HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT"
-    ];
-    RUNTIME_CONTEXT_DATA_MODEL = {
-      derivativesSourceIntervals: "15m",
-      derivativesDerivedIntervals: "1h",
-      derivativesHourlyFallback: "stored-1h",
-      derivativesDataModelVersion: 2,
-      coinMarketCapAvailabilityModel: "closed-interval-all-daily",
-      coinMarketCapDataModelVersion: 3,
-      binanceBreadthUniverseModel: "fixed-versioned-top5-top10-top30-top50-top100",
-      binanceBreadthDataModelVersion: 2,
-      hyperliquidWhaleCanonicalInterval: "1m",
-      hyperliquidWhaleGateMinNotionalUsd: 5e4,
-      hyperliquidWhaleMinCoveragePct: 0.8,
-      hyperliquidWhaleDataModelVersion: import_types8.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-    };
     normalizeForStableJson2 = (value) => {
       if (Array.isArray(value)) {
         return value.map(normalizeForStableJson2);
@@ -25476,364 +25636,65 @@ var init_runtimeLineage = __esm({
       return Number.isFinite(maxLossValue) ? maxLossValue : null;
     };
     fingerprintRuntimeValue = (value) => (0, import_node_crypto11.createHash)("sha256").update(JSON.stringify(normalizeForStableJson2(value))).digest("hex").slice(0, 16);
-    gitLineageCache = /* @__PURE__ */ new Map();
-    gateFingerprintCache = /* @__PURE__ */ new Map();
-    binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
-    snapshotFingerprintCache = /* @__PURE__ */ new Map();
-    resolveGitLineage = (projectRoot15) => {
-      const cached = gitLineageCache.get(projectRoot15);
-      if (cached) {
-        return cached;
-      }
-      const envSha = String(process.env.TRADEJS_GIT_SHA ?? "").trim();
-      if (envSha && envSha !== "unknown") {
-        const result = {
-          gitSha: envSha,
-          gitDirty: false
-        };
-        gitLineageCache.set(projectRoot15, result);
-        return result;
-      }
-      try {
-        const gitSha = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", "HEAD"], {
-          cwd: projectRoot15,
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "ignore"]
-        }).trim();
-        const status = (0, import_node_child_process6.execFileSync)(
-          "git",
-          ["status", "--porcelain", "--untracked-files=normal"],
-          {
-            cwd: projectRoot15,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"]
-          }
-        ).trim();
-        const result = {
-          gitSha: gitSha || null,
-          gitDirty: status.length > 0
-        };
-        gitLineageCache.set(projectRoot15, result);
-        return result;
-      } catch {
-        const result = {
-          gitSha: null,
-          gitDirty: null
-        };
-        gitLineageCache.set(projectRoot15, result);
-        return result;
-      }
-    };
-    readOptionalFile = async (filePath) => {
-      try {
-        return await import_promises23.default.readFile(filePath);
-      } catch {
-        return null;
-      }
-    };
-    resolveBinanceBreadthFingerprint = async (projectRoot15) => {
-      if (binanceBreadthFingerprintCache.has(projectRoot15)) {
-        return binanceBreadthFingerprintCache.get(projectRoot15) ?? null;
+    buildRuntimeLineage = async ({
+      strategyRevision,
+      deploymentCompositionId,
+      strategyPackageVersion,
+      strategyDependencyVersions,
+      runtimePackageVersion,
+      config: config2
+    }) => {
+      if (!/^sr1:[a-f0-9]{16}$/.test(strategyRevision)) {
+        throw new Error(`Invalid strategy revision: ${strategyRevision}`);
       }
-      const content = await readOptionalFile(
-        import_node_path17.default.join(
-          projectRoot15,
-          "packages/node/src/config/binanceBreadthUniverses.json"
-        )
-      );
-      let result = null;
-      if (content) {
-        try {
-          const parsed = JSON.parse(content.toString("utf8"));
-          result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
-        } catch {
-          result = null;
-        }
+      if (!/^dc1:[a-f0-9]{16}$/.test(deploymentCompositionId)) {
+        throw new Error(
+          `Invalid deployment composition id: ${deploymentCompositionId}`
+        );
       }
-      binanceBreadthFingerprintCache.set(projectRoot15, result);
-      return result;
-    };
-    resolveSnapshotFingerprint = async (projectRoot15, relativePath) => {
-      const cacheKey = `${projectRoot15}:${relativePath}`;
-      if (snapshotFingerprintCache.has(cacheKey)) {
-        return snapshotFingerprintCache.get(cacheKey) ?? null;
+      if (!strategyPackageVersion.trim() || !runtimePackageVersion.trim()) {
+        throw new Error("Invalid revision package versions");
       }
-      const content = await readOptionalFile(import_node_path17.default.join(projectRoot15, relativePath));
-      let result = null;
-      if (content) {
-        try {
-          const parsed = JSON.parse(content.toString("utf8"));
-          result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
-        } catch {
-          result = null;
-        }
+      if (Object.keys(strategyDependencyVersions).length === 0 || Object.entries(strategyDependencyVersions).some(
+        ([name, version]) => !name.startsWith("@tradejs/") || typeof version !== "string" || !version.trim()
+      )) {
+        throw new Error("Invalid strategy dependency versions");
       }
-      snapshotFingerprintCache.set(cacheKey, result);
-      return result;
-    };
-    resolveRuntimeGateFingerprint = async ({
-      projectRoot: projectRoot15,
-      strategyName,
-      gitSha
-    }) => {
-      const cacheKey = `${projectRoot15}:${strategyName}:${gitSha ?? "unknown"}`;
-      const cached = gateFingerprintCache.get(cacheKey);
-      if (cached) return cached;
-      const result = await resolveStrategyGateFingerprint({
-        projectRoot: projectRoot15,
-        strategyName,
-        gitSha
-      });
-      gateFingerprintCache.set(cacheKey, result);
-      return result;
+      return {
+        schemaVersion: 3,
+        strategyRevision,
+        deploymentCompositionId,
+        strategyPackageVersion,
+        strategyDependencyVersions,
+        runtimePackageVersion,
+        maxLossValue: resolveRuntimeMaxLossValue(config2)
+      };
     };
-    runtimeLineageKey = (lineage) => lineage.schemaVersion === 3 ? [
+    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(":");
     runtimeLineagesMatch = (left, right) => left != null && right != null && runtimeLineageKey(left) === runtimeLineageKey(right);
     runtimeLineagesComparable = (left, right) => runtimeLineagesMatch(left, right) && typeof left?.maxLossValue === "number" && Number.isFinite(left.maxLossValue) && typeof right?.maxLossValue === "number" && Number.isFinite(right.maxLossValue) && left.maxLossValue === right.maxLossValue;
   }
 });
 
-// src/lib/runtimeEvidenceDeployment.ts
-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";
-    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
-    isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-    isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
-      ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
-    );
-    INTERVALS = /* @__PURE__ */ new Set([
-      "1",
-      "3",
-      "5",
-      "15",
-      "30",
-      "60",
-      "120",
-      "240",
-      "360",
-      "720",
-      "D",
-      "W",
-      "M"
-    ]);
-    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(
-          "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
-      };
-    };
-    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,
-      label: deployment.label,
-      connectorName: deployment.connectorName,
-      provider: deployment.provider,
-      accountId: deployment.accountId,
-      enabled: deployment.enabled,
-      strategies: deployment.strategies.map(
-        ({ strategyName, strategyRevision, enabled, controlState, selection }) => ({
-          strategyName,
-          strategyRevision,
-          enabled,
-          controlState,
-          ...selection ? { selection } : {}
-        })
-      ),
-      ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-      ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-    });
-    resolveRuntimeEvidenceDeploymentSnapshot = async ({
-      userName: userName3,
-      projectRoot: projectRoot15,
-      deploymentId
-    }) => {
-      const [deployment, strategies] = await Promise.all([
-        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot15, deploymentId }),
-        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot15, 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: interval4,
-            universe,
-            accountId,
-            strategyPackage,
-            strategyPackageVersion,
-            strategyDependencyVersions,
-            runtimePackageVersion,
-            strategyConfig,
-            selection
-          }) => ({
-            strategyName,
-            strategyRevision,
-            enabled,
-            controlState,
-            interval: interval4,
-            universe,
-            ...accountId ? { accountId } : {},
-            strategyPackage,
-            strategyPackageVersion,
-            strategyDependencyVersions,
-            runtimePackageVersion,
-            strategyConfig,
-            ...selection ? { selection } : {}
-          })
-        ),
-        ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-        ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-      };
-    };
-  }
-});
-
 // src/scripts/runtimeEvidence.ts
 var runtimeEvidence_exports = {};
 __export(runtimeEvidence_exports, {
   main: () => main34,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises24, import_node_path18, import_args26, import_chalk39, flags25, projectRoot9, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main34;
+var import_promises23, import_node_path17, import_args26, import_chalk39, flags25, projectRoot9, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main34;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
-    import_promises24 = __toESM(require("fs/promises"));
-    import_node_path18 = __toESM(require("path"));
+    import_promises23 = __toESM(require("fs/promises"));
+    import_node_path17 = __toESM(require("path"));
     import_args26 = __toESM(require("args"));
     import_chalk39 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
@@ -25947,20 +25808,46 @@ var init_runtimeEvidence = __esm({
         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: flags25.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",
@@ -25977,13 +25864,13 @@ var init_runtimeEvidence = __esm({
         deployment,
         runtime
       };
-      const outPath = import_node_path18.default.resolve(projectRoot9, String(flags25.out));
-      await import_promises24.default.mkdir(import_node_path18.default.dirname(outPath), { recursive: true });
-      await import_promises24.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      const outPath = import_node_path17.default.resolve(projectRoot9, String(flags25.out));
+      await import_promises23.default.mkdir(import_node_path17.default.dirname(outPath), { recursive: true });
+      await import_promises23.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       const publishDir = String(flags25.publishDir ?? "").trim();
       const published = publishDir ? await publishRuntimeEvidenceBundle({
-        publishRoot: import_node_path18.default.resolve(projectRoot9, publishDir),
+        publishRoot: import_node_path17.default.resolve(projectRoot9, publishDir),
         deploymentId,
         userName: String(flags25.user),
         startTime,
@@ -25991,12 +25878,10 @@ var init_runtimeEvidence = __esm({
         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_chalk39.default.green(`Wrote ${outPath}`));
@@ -26019,17 +25904,17 @@ 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, compareBundles, inspectRuntimeEvidenceBundleSupport, listRuntimeEvidenceBundleStatuses, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process6, import_promises24, import_node_path18, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment2, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_child_process7 = require("child_process");
-    import_promises25 = __toESM(require("fs/promises"));
-    import_node_path19 = __toESM(require("path"));
+    import_node_child_process6 = require("child_process");
+    import_promises24 = __toESM(require("fs/promises"));
+    import_node_path18 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceDeployment();
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process7.execFile);
+    execFileAsync = (0, import_node_util.promisify)(import_node_child_process6.execFile);
     isExistingDestinationError2 = (error) => {
       const code = error.code;
       return code === "EEXIST" || code === "ENOTEMPTY";
@@ -26059,58 +25944,30 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(source),
       withTrailingSlash(destination)
     ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path19.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
+    receiptPath = (receiptsRoot, artifactId) => import_node_path18.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
     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 ({
+    listPendingRuntimeEvidenceBundles = async ({
       evidenceRoot,
       deploymentId
     }) => {
       const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const artifactsRoot = import_node_path19.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path19.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const artifactsRoot = import_node_path18.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path18.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;
+        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
         try {
-          await import_promises25.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+          await import_promises24.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 });
-        }
+        pending.push(verified);
       }
-      return {
-        pending: pending.sort(compareBundles),
-        unsupported: unsupported.sort(
-          (left, right) => compareBundles(left.bundle, right.bundle)
-        )
-      };
+      return pending.sort(compareBundles);
     };
     markRuntimeEvidenceBundleProcessed = async ({
       evidenceRoot,
@@ -26125,7 +25982,7 @@ var init_runtimeEvidenceSync = __esm({
           `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
         );
       }
-      const receiptsRoot = import_node_path19.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const receiptsRoot = import_node_path18.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
       const temporaryPath = `${finalPath}.tmp-${process.pid}`;
       const receipt = {
@@ -26135,14 +25992,14 @@ var init_runtimeEvidenceSync = __esm({
         processedAt: Date.now(),
         scorecardPath: scorecardPath ?? null
       };
-      await import_promises25.default.mkdir(receiptsRoot, { recursive: true });
-      await import_promises25.default.writeFile(
+      await import_promises24.default.mkdir(receiptsRoot, { recursive: true });
+      await import_promises24.default.writeFile(
         temporaryPath,
         `${JSON.stringify(receipt, null, 2)}
 `,
         "utf8"
       );
-      await import_promises25.default.rename(temporaryPath, finalPath);
+      await import_promises24.default.rename(temporaryPath, finalPath);
       return finalPath;
     };
     syncRuntimeEvidenceBundles = async ({
@@ -26157,11 +26014,11 @@ var init_runtimeEvidenceSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const inboxRoot = import_node_path19.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path19.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path18.default.join(evidenceRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path18.default.join(evidenceRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises25.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises25.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises24.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises24.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
@@ -26177,14 +26034,15 @@ var init_runtimeEvidenceSync = __esm({
             `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        const destinationDir = import_node_path19.default.join(
+        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
+        const destinationDir = import_node_path18.default.join(
           artifactsRoot,
           ...dateParts2(verified.manifest.window.endTime),
           safeSegment2(verified.manifest.artifactId, "artifact")
         );
-        await import_promises25.default.mkdir(import_node_path19.default.dirname(destinationDir), { recursive: true });
+        await import_promises24.default.mkdir(import_node_path18.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises25.default.rename(bundleDir, destinationDir);
+          await import_promises24.default.rename(bundleDir, destinationDir);
         } catch (error) {
           if (!isExistingDestinationError2(error)) throw error;
           const existing = await verifyRuntimeEvidenceBundle(destinationDir);
@@ -26193,11 +26051,11 @@ var init_runtimeEvidenceSync = __esm({
               `Conflicting runtime evidence artifact ${verified.manifest.artifactId}`
             );
           }
-          await import_promises25.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises24.default.rm(bundleDir, { recursive: true, force: true });
         }
         received.push(await verifyRuntimeEvidenceBundle(destinationDir));
       }
-      const statuses = await listRuntimeEvidenceBundleStatuses({
+      const pending = await listPendingRuntimeEvidenceBundles({
         evidenceRoot,
         deploymentId: safeDeploymentId
       });
@@ -26206,7 +26064,7 @@ var init_runtimeEvidenceSync = __esm({
         stdout: String(transfer.stdout ?? ""),
         stderr: String(transfer.stderr ?? ""),
         received,
-        ...statuses
+        pending
       };
     };
   }
@@ -26218,11 +26076,11 @@ __export(runtimeEvidenceSync_exports, {
   main: () => main35,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path20, import_args27, import_chalk40, flags26, projectRoot10, runtimeEvidenceSync, main35;
+var import_node_path19, import_args27, import_chalk40, flags26, projectRoot10, runtimeEvidenceSync, main35;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path20 = __toESM(require("path"));
+    import_node_path19 = __toESM(require("path"));
     import_args27 = __toESM(require("args"));
     import_chalk40 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
@@ -26250,7 +26108,7 @@ var init_runtimeEvidenceSync2 = __esm({
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path20.default.resolve(projectRoot10, String(flags26.dir));
+      const evidenceRoot = import_node_path19.default.resolve(projectRoot10, String(flags26.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
@@ -26258,7 +26116,7 @@ var init_runtimeEvidenceSync2 = __esm({
       });
       console.log(
         import_chalk40.default.green(
-          `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length} unsupported=${result.unsupported.length}`
+          `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length}`
         )
       );
       console.log(
@@ -26275,13 +26133,6 @@ 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,
@@ -26294,11 +26145,12 @@ var init_runtimeEvidenceSync2 = __esm({
 });
 
 // src/lib/runtimeScorecard.ts
-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 asRecord6, asArray3, finiteNumber5, finiteString2, packageVersionMap, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildEmbeddedLineageScope, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, buildDistributions, buildDistributionDelta, sum2, statsCount, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
 var init_runtimeScorecard = __esm({
   "src/lib/runtimeScorecard.ts"() {
     "use strict";
     init_runtimeLineage();
+    init_runtimeEvidenceDeployment();
     asRecord6 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     asArray3 = (value) => Array.isArray(value) ? value : [];
     finiteNumber5 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -26336,75 +26188,6 @@ var init_runtimeScorecard = __esm({
         statsBuckets: asArray3(runtime.evaluationStatsBuckets).map(asRecord6).filter((item) => item != null)
       };
     };
-    buildRuntimeLineageSummary = (rows) => {
-      const lineageRows = [
-        ...rows.evaluations,
-        ...rows.signals,
-        ...rows.trades,
-        ...rows.lineageScopes.map((scope) => ({
-          runtimeLineage: scope.lineage
-        }))
-      ];
-      const lineages = lineageRows.map((row) => asRecord6(row.runtimeLineage)).filter((lineage) => lineage != null);
-      const identities = /* @__PURE__ */ new Map();
-      for (const lineage of lineages) {
-        const identity2 = lineage.schemaVersion === 3 ? {
-          schemaVersion: 3,
-          strategyRevision: finiteString2(lineage.strategyRevision),
-          deploymentCompositionId: finiteString2(
-            lineage.deploymentCompositionId
-          ),
-          strategyPackageVersion: finiteString2(
-            lineage.strategyPackageVersion
-          ),
-          strategyDependencyVersions: packageVersionMap(
-            lineage.strategyDependencyVersions
-          ),
-          runtimePackageVersion: finiteString2(lineage.runtimePackageVersion),
-          maxLossValue: finiteNumber5(lineage.maxLossValue)
-        } : {
-          schemaVersion: 1,
-          compositionId: finiteString2(lineage.compositionId),
-          gitSha: finiteString2(lineage.gitSha),
-          gitDirty: typeof lineage.gitDirty === "boolean" ? lineage.gitDirty : null,
-          gateFingerprint: finiteString2(lineage.gateFingerprint),
-          configFingerprint: finiteString2(lineage.configFingerprint),
-          contextFingerprint: finiteString2(lineage.contextFingerprint),
-          maxLossValue: finiteNumber5(lineage.maxLossValue)
-        };
-        identities.set(JSON.stringify(identity2), identity2);
-      }
-      const identity = identities.size === 1 ? [...identities.values()][0] : null;
-      const schemaVersion = finiteNumber5(identity?.schemaVersion);
-      const identityComplete = lineages.length > 0 && identity != null && (schemaVersion === 3 && finiteString2(identity.strategyRevision) != null && finiteString2(identity.deploymentCompositionId) != null && finiteString2(identity.strategyPackageVersion) != null && packageVersionMap(identity.strategyDependencyVersions) != null && finiteString2(identity.runtimePackageVersion) != null || schemaVersion === 1 && identity.compositionId != null && identity.gitSha != null && identity.gitDirty === false && identity.gateFingerprint != null && identity.configFingerprint != null && identity.contextFingerprint != null) && identity.maxLossValue != null;
-      const coverageComplete = lineageRows.length > 0 && lineages.length === lineageRows.length;
-      const complete = identityComplete && coverageComplete;
-      const lineageKey = identityComplete ? runtimeLineageKey(identity) : null;
-      return {
-        complete,
-        identityComplete,
-        coverageComplete,
-        conflicts: identities.size > 1,
-        rows: lineageRows.length,
-        rowsWithLineage: lineages.length,
-        schemaVersion,
-        lineageKey,
-        strategyRevision: finiteString2(identity?.strategyRevision),
-        deploymentCompositionId: finiteString2(identity?.deploymentCompositionId),
-        strategyPackageVersion: finiteString2(identity?.strategyPackageVersion),
-        strategyDependencyVersions: packageVersionMap(
-          identity?.strategyDependencyVersions
-        ),
-        runtimePackageVersion: finiteString2(identity?.runtimePackageVersion),
-        compositionId: finiteString2(identity?.compositionId),
-        gitSha: finiteString2(identity?.gitSha),
-        gitDirty: typeof identity?.gitDirty === "boolean" ? identity.gitDirty : null,
-        gateFingerprint: finiteString2(identity?.gateFingerprint),
-        configFingerprint: finiteString2(identity?.configFingerprint),
-        contextFingerprint: finiteString2(identity?.contextFingerprint),
-        maxLossValue: finiteNumber5(identity?.maxLossValue)
-      };
-    };
     buildEmbeddedLineageScope = ({
       artifact,
       rows,
@@ -26516,12 +26299,6 @@ var init_runtimeScorecard = __esm({
           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) => [
@@ -26537,12 +26314,6 @@ var init_runtimeScorecard = __esm({
         }
       };
     };
-    belongsToRuntimeLineage = (row, summary) => {
-      if (!summary.identityComplete || !summary.lineageKey) return false;
-      const lineage = asRecord6(row.runtimeLineage);
-      if (!lineage) return false;
-      return runtimeLineageKey(lineage) === summary.lineageKey && finiteNumber5(lineage.maxLossValue) === summary.maxLossValue;
-    };
     runtimeDeploymentBinding = (artifact) => {
       const deployment = asRecord6(asRecord6(artifact)?.deployment);
       return {
@@ -26724,10 +26495,6 @@ var init_runtimeScorecard = __esm({
         runtimeOnly: finiteNumber5(counts?.runtimeOnly) ?? 0
       };
     };
-    getCalibrationSummary = (artifact) => {
-      const root = asRecord6(artifact) ?? {};
-      return asRecord6(asRecord6(root.summary)?.all) ?? null;
-    };
     getProspectiveSummary = (artifact) => {
       const root = asRecord6(artifact);
       if (!root || root.reportType !== "strategy-prospective-evidence") return null;
@@ -26753,6 +26520,10 @@ var init_runtimeScorecard = __esm({
       strategy = null,
       llmComparatorPolicy = "ai_approved_only"
     }) => {
+      assertCurrentRuntimeEvidenceArtifact(runtimeArtifact);
+      for (const artifact of historyRuntimeArtifacts) {
+        assertCurrentRuntimeEvidenceArtifact(artifact);
+      }
       const scopedRuntimeArtifact = filterArtifactByStrategy(
         runtimeArtifact,
         strategy
@@ -26767,7 +26538,12 @@ var init_runtimeScorecard = __esm({
         rows,
         strategy
       });
-      const runtimeLineage = embeddedLineageScope?.summary ?? buildRuntimeLineageSummary(rows);
+      if (!embeddedLineageScope) {
+        throw new Error(
+          "Runtime scorecard requires the current embedded deployment lineage"
+        );
+      }
+      const runtimeLineage = embeddedLineageScope.summary;
       const window = runtimeWindow(runtimeArtifact);
       const startTime = finiteNumber5(window.startTime) ?? generatedAt - 864e5;
       const endTime = finiteNumber5(window.endTime) ?? generatedAt;
@@ -26815,32 +26591,26 @@ var init_runtimeScorecard = __esm({
       const lineage = asRecord6(replayComparison?.lineage);
       const lineageReason = finiteString2(lineage?.reason);
       const calibrationRoot = asRecord6(calibrationArtifact) ?? {};
-      const calibrationSummary = asRecord6(calibrationRoot.summary);
-      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 calibrationSamples = asArray3(calibrationRoot.samples).map(asRecord6).filter((item) => item != null).filter((item) => !strategy || finiteString2(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
       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 actualSlippageBps = averageSampleMetric("signalToFillAdverseBps");
+      const residualVsModelBps = averageSampleMetric("residualVsCurrentModelBps");
       const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
       const historyTrades = dedupeTrades([
         ...scopedHistoryArtifacts,
         scopedRuntimeArtifact
       ]);
       const comparableHistoryTrades = historyTrades.filter(
-        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
       );
       const comparableCurrentClosedTrades = currentClosedTrades.filter(
-        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
       );
       const comparableFills = rows.trades.filter(
-        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
       );
       const currentDistributions = buildDistributions(rows);
       const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
@@ -27094,11 +26864,11 @@ ${reactions}
 });
 
 // src/lib/strategyRelease/liveDiagnosis.ts
-var import_types9, buildStrategyLiveDiagnosis, buildStrategyLiveDiagnosisFromScorecard;
+var import_types8, buildStrategyLiveDiagnosis, buildStrategyLiveDiagnosisFromScorecard;
 var init_liveDiagnosis = __esm({
   "src/lib/strategyRelease/liveDiagnosis.ts"() {
     "use strict";
-    import_types9 = require("@tradejs/types");
+    import_types8 = require("@tradejs/types");
     buildStrategyLiveDiagnosis = (input) => {
       const minimumClosedTrades = input.minimumClosedTrades ?? 20;
       const minimumParityRatio = input.minimumParityRatio ?? 0.95;
@@ -27126,7 +26896,7 @@ var init_liveDiagnosis = __esm({
         attributionIncomplete && verdict === "GENERALIZATION_FAILURE" ? "Collect matched shadow raw-core, deterministic-gate, and causal regime evidence without changing the composition." : "Collect more verified prospective outcomes without changing the composition."
       ];
       return {
-        schema: import_types9.STRATEGY_LIVE_DIAGNOSIS_SCHEMA,
+        schema: import_types8.STRATEGY_LIVE_DIAGNOSIS_SCHEMA,
         strategy: input.strategy,
         compositionId: input.compositionId,
         createdAt: input.createdAt,
@@ -27166,7 +26936,7 @@ var init_liveDiagnosis = __esm({
       );
       const orderFailureRate = scorecard.funnel.orderAttempts ? scorecard.funnel.orderFailures / scorecard.funnel.orderAttempts : null;
       const lineage = scorecard.lineage;
-      const lineageComparable = scorecard.parity.lineageReason == null && lineage?.complete === true && lineage.conflicts === false && lineage.compositionId === manifest.composition.compositionId && lineage.gitDirty === false && lineage.gitSha === manifest.composition.gitSha && lineage.configFingerprint === manifest.composition.runtimeConfigFingerprint && lineage.gateFingerprint === manifest.composition.gateFingerprint && lineage.contextFingerprint === manifest.composition.runtimeContextFingerprint;
+      const lineageComparable = scorecard.parity.lineageReason == null && lineage?.complete === true && lineage.conflicts === false && lineage.schemaVersion === 3 && lineage.strategyRevision != null && lineage.deploymentCompositionId != null && lineage.strategyPackageVersion != null && lineage.strategyDependencyVersions != null && lineage.runtimePackageVersion != null;
       const releaseMaxLossValue = manifest.composition.maxLossValue;
       const runtimeMaxLossValue = lineage?.maxLossValue ?? null;
       const riskScaleComparable = Number.isFinite(releaseMaxLossValue) && releaseMaxLossValue > 0 && runtimeMaxLossValue != null && Number.isFinite(runtimeMaxLossValue) && runtimeMaxLossValue > 0;
@@ -27341,7 +27111,7 @@ function assert3(condition, message) {
 async function collectReleaseEvidenceReferences(references) {
   return Promise.all(
     references.map(async (reference) => {
-      const actualSha256 = await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(reference.path);
+      const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(reference.path);
       assert3(
         actualSha256 === reference.sha256,
         `evidence ${reference.artifactId} checksum mismatch`
@@ -27349,7 +27119,7 @@ async function collectReleaseEvidenceReferences(references) {
       let artifact;
       try {
         const parsed = JSON.parse(
-          await import_promises26.default.readFile(reference.path, "utf8")
+          await import_promises25.default.readFile(reference.path, "utf8")
         );
         assert3(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
@@ -27496,15 +27266,15 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto12, import_promises26, import_node_path21, import_types10, import_strategyReleaseEvidence3, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_STABLE_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, MIN_SELECTION_GRADE_TERMINAL_EVENTS, safeSegment3, compactTimestamp2, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber6, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
+var import_node_crypto12, import_promises25, import_node_path20, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_STABLE_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, MIN_SELECTION_GRADE_TERMINAL_EVENTS, safeSegment3, compactTimestamp2, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber6, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
 var init_strategyRelease = __esm({
   "src/lib/strategyRelease.ts"() {
     "use strict";
     import_node_crypto12 = require("crypto");
-    import_promises26 = __toESM(require("fs/promises"));
-    import_node_path21 = __toESM(require("path"));
-    import_types10 = require("@tradejs/types");
-    import_strategyReleaseEvidence3 = require("@tradejs/infra/strategyReleaseEvidence");
+    import_promises25 = __toESM(require("fs/promises"));
+    import_node_path20 = __toESM(require("path"));
+    import_types9 = require("@tradejs/types");
+    import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
     init_monitoringProfile();
     init_evidenceRetention();
@@ -27516,17 +27286,17 @@ var init_strategyRelease = __esm({
     REQUIRED_STABLE_TERMINAL_WINDOWS = [365, 180, 90];
     MIN_RECENT_DIRECTION_REPAIR_EVENTS = 20;
     MIN_SELECTION_GRADE_TERMINAL_EVENTS = 50;
-    safeSegment3 = import_strategyReleaseEvidence3.safeStrategyEvidenceSegment;
-    compactTimestamp2 = import_strategyReleaseEvidence3.compactStrategyEvidenceTimestamp;
+    safeSegment3 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
+    compactTimestamp2 = import_strategyReleaseEvidence2.compactStrategyEvidenceTimestamp;
     verifyFullPeriodChartArtifact = async (input) => {
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path21.default.resolve(artifact.path);
-        if (await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
+        const artifactPath = import_node_path20.default.resolve(artifact.path);
+        if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
-        const report = JSON.parse(await import_promises26.default.readFile(artifactPath, "utf8"));
+        const report = JSON.parse(await import_promises25.default.readFile(artifactPath, "utf8"));
         return Boolean(
           report.chart?.persisted === true && report.chart.cardIds?.length && report.errors?.failed === 0 && report.run?.strategy === input.strategy && report.run.mode === "local-deterministic" && report.run.recent === 0 && report.run.since == null && report.run.until == null && Number(report.run.sourceRows) > 0
         );
@@ -27537,11 +27307,11 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path21.default.resolve(artifact.path);
-        if (await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
+        const artifactPath = import_node_path20.default.resolve(artifact.path);
+        if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
-        return JSON.parse(await import_promises26.default.readFile(artifactPath, "utf8"));
+        return JSON.parse(await import_promises25.default.readFile(artifactPath, "utf8"));
       } catch {
         return null;
       }
@@ -27694,8 +27464,8 @@ var init_strategyRelease = __esm({
         summary: "Start the exact frozen composition as a micro-forward test at MAX_LOSS_VALUE=1; do not retune an underpowered or exposed recent tail."
       };
     };
-    canonicalStrategyReleaseJson = (value) => (0, import_strategyReleaseEvidence3.canonicalStrategyEvidenceJson)(value);
-    strategyReleaseSha256 = (value) => (0, import_strategyReleaseEvidence3.strategyEvidenceSha256)(value);
+    canonicalStrategyReleaseJson = (value) => (0, import_strategyReleaseEvidence2.canonicalStrategyEvidenceJson)(value);
+    strategyReleaseSha256 = (value) => (0, import_strategyReleaseEvidence2.strategyEvidenceSha256)(value);
     assertFingerprint = (value, label) => assert3(SHA256_RE2.test(value), `${label} must be a lowercase SHA-256`);
     assertLineageFingerprint = (value, label) => assert3(
       LINEAGE_FINGERPRINT_RE.test(value),
@@ -28061,7 +27831,7 @@ var init_strategyRelease = __esm({
         verdict
       };
       return {
-        schema: import_types10.STRATEGY_RELEASE_SCHEMA,
+        schema: import_types9.STRATEGY_RELEASE_SCHEMA,
         releaseId: `${safeSegment3(input.strategy, "strategy")}_${compactTimestamp2(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
         strategy: input.strategy,
         createdAt: input.createdAt,
@@ -28086,7 +27856,7 @@ var init_strategyRelease = __esm({
       manifest
     });
     verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises26.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises25.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       const envelope = value;
       assert3(
         envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -28102,7 +27872,7 @@ var init_strategyRelease = __esm({
       );
       const manifest = envelope.manifest;
       assert3(
-        manifest.schema === import_types10.STRATEGY_RELEASE_SCHEMA,
+        manifest.schema === import_types9.STRATEGY_RELEASE_SCHEMA,
         "manifest schema mismatch"
       );
       const rebuilt = createStrategyReleaseManifest({
@@ -28137,8 +27907,8 @@ var init_strategyRelease = __esm({
       return envelope;
     };
     verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises26.default.readFile(valueOrPath, "utf8")) : valueOrPath;
-      return (0, import_strategyReleaseEvidence3.verifyStrategyEvidenceMarkerEnvelope)(value);
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises25.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      return (0, import_strategyReleaseEvidence2.verifyStrategyEvidenceMarkerEnvelope)(value);
     };
     releaseMarkers = (manifest) => {
       const common = {
@@ -28199,21 +27969,21 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises26.default.mkdir(import_node_path21.default.dirname(filePath), { recursive: true });
-      await import_promises26.default.writeFile(
+      await import_promises25.default.mkdir(import_node_path20.default.dirname(filePath), { recursive: true });
+      await import_promises25.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
 `,
         "utf8"
       );
-      await import_promises26.default.rename(temporaryPath, filePath);
+      await import_promises25.default.rename(temporaryPath, filePath);
     };
     publishStrategyRelease = async ({
       rootDir,
       manifest
     }) => {
       const envelope = createStrategyReleaseEnvelope(manifest);
-      const markerEnvelope = (0, import_strategyReleaseEvidence3.createStrategyEvidenceMarkerEnvelope)({
+      const markerEnvelope = (0, import_strategyReleaseEvidence2.createStrategyEvidenceMarkerEnvelope)({
         strategy: manifest.strategy,
         createdAt: manifest.createdAt,
         markers: releaseMarkers(manifest),
@@ -28223,13 +27993,13 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path21.default.join(
+      const releasePath = import_node_path20.default.join(
         rootDir,
         "releases",
         safeSegment3(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path21.default.join(
+      const markerPath = import_node_path20.default.join(
         rootDir,
         "markers",
         safeSegment3(manifest.strategy, "strategy"),
@@ -28303,19 +28073,19 @@ var init_strategyRelease = __esm({
           severity: diagnosis.verdict === "EXPECTED_DRAWDOWN" ? "info" : "warning"
         }
       ];
-      const markerEnvelope = (0, import_strategyReleaseEvidence3.createStrategyEvidenceMarkerEnvelope)({
+      const markerEnvelope = (0, import_strategyReleaseEvidence2.createStrategyEvidenceMarkerEnvelope)({
         strategy: diagnosis.strategy,
         createdAt: diagnosis.createdAt,
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path21.default.join(
+      const diagnosisPath = import_node_path20.default.join(
         rootDir,
         "diagnoses",
         safeSegment3(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path21.default.join(
+      const markerPath = import_node_path20.default.join(
         rootDir,
         "markers",
         safeSegment3(diagnosis.strategy, "strategy"),
@@ -28505,11 +28275,11 @@ var init_strategyRelease = __esm({
       const specSha256 = finiteString3(artifact.specSha256);
       assert3(researchId != null, "core result researchId is required");
       assert3(specSha256 != null, "core result specSha256 is required");
-      const researchDir = import_node_path21.default.dirname(resultPath);
-      const manifestPath = import_node_path21.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path21.default.join(researchDir, "spec.json");
-      const manifestBytes = await import_promises26.default.readFile(manifestPath).catch(() => null);
-      const specBytes = await import_promises26.default.readFile(specPath).catch(() => null);
+      const researchDir = import_node_path20.default.dirname(resultPath);
+      const manifestPath = import_node_path20.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path20.default.join(researchDir, "spec.json");
+      const manifestBytes = await import_promises25.default.readFile(manifestPath).catch(() => null);
+      const specBytes = await import_promises25.default.readFile(specPath).catch(() => null);
       assert3(
         manifestBytes != null && specBytes != null,
         "core result must belong to a completed core research bundle"
@@ -28525,15 +28295,15 @@ var init_strategyRelease = __esm({
         artifactHashes ?? {}
       )) {
         assert3(
-          !import_node_path21.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path20.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
           typeof expectedSha256 === "string" && SHA256_RE2.test(expectedSha256),
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
-        const actualSha256 = await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(
-          import_node_path21.default.join(researchDir, relativePath)
+        const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
+          import_node_path20.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -28550,13 +28320,13 @@ __export(runtimeScorecard_exports, {
   main: () => main36,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises27, import_node_crypto13, import_node_path22, import_args28, import_chalk41, flags27, projectRoot11, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main36;
+var import_promises26, import_node_crypto13, import_node_path21, import_args28, import_chalk41, flags27, projectRoot11, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main36;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
-    import_promises27 = __toESM(require("fs/promises"));
+    import_promises26 = __toESM(require("fs/promises"));
     import_node_crypto13 = require("crypto");
-    import_node_path22 = __toESM(require("path"));
+    import_node_path21 = __toESM(require("path"));
     import_args28 = __toESM(require("args"));
     import_chalk41 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
@@ -28620,15 +28390,15 @@ var init_runtimeScorecard2 = __esm({
     projectRoot11 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     resolveOptionalPath = (value) => {
       const raw = String(value ?? "").trim();
-      return raw ? import_node_path22.default.resolve(projectRoot11, raw) : null;
+      return raw ? import_node_path21.default.resolve(projectRoot11, raw) : null;
     };
-    readJson = async (filePath) => filePath ? JSON.parse(await import_promises27.default.readFile(filePath, "utf8")) : void 0;
+    readJson = async (filePath) => filePath ? JSON.parse(await import_promises26.default.readFile(filePath, "utf8")) : void 0;
     assertReportType = (artifact, expected, label) => {
       if (artifact != null && (!artifact || typeof artifact !== "object" || Array.isArray(artifact) || artifact.reportType !== expected)) {
         throw new Error(`${label} must be a ${expected} artifact`);
       }
     };
-    sha256File2 = async (filePath) => (0, import_node_crypto13.createHash)("sha256").update(await import_promises27.default.readFile(filePath)).digest("hex");
+    sha256File2 = async (filePath) => (0, import_node_crypto13.createHash)("sha256").update(await import_promises26.default.readFile(filePath)).digest("hex");
     loadHistoryArtifacts = async (historyDir) => {
       if (!historyDir) return [];
       const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
@@ -28698,13 +28468,13 @@ var init_runtimeScorecard2 = __esm({
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path22.default.resolve(projectRoot11, String(flags27.out));
+      const outPath = import_node_path21.default.resolve(projectRoot11, String(flags27.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises27.default.mkdir(import_node_path22.default.dirname(outPath), { recursive: true });
+      await import_promises26.default.mkdir(import_node_path21.default.dirname(outPath), { recursive: true });
       await Promise.all([
-        import_promises27.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+        import_promises26.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-        import_promises27.default.writeFile(
+        import_promises26.default.writeFile(
           markdownPath,
           formatRuntimeScorecardMarkdown(scorecard),
           "utf8"
@@ -28718,7 +28488,7 @@ var init_runtimeScorecard2 = __esm({
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
       const strategyReleaseRoot = resolveOptionalPath(flags27.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
-        await import_promises27.default.writeFile(
+        await import_promises26.default.writeFile(
           diagnosisPath,
           `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -28739,7 +28509,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path22.default.basename(sourcePath),
+                artifactId: import_node_path21.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -28750,9 +28520,9 @@ var init_runtimeScorecard2 = __esm({
       let receiptPath2 = null;
       if (flags27.markProcessed) {
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path22.default.resolve(projectRoot11, String(flags27.evidenceDir)),
+          evidenceRoot: import_node_path21.default.resolve(projectRoot11, String(flags27.evidenceDir)),
           deploymentId: String(flags27.deployment),
-          bundleDir: import_node_path22.default.dirname(runtimeEvidencePath),
+          bundleDir: import_node_path21.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath
         });
       }
@@ -28945,14 +28715,14 @@ __export(strategyRelease_exports, {
   main: () => main38,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises28, import_node_fs5, import_node_readline2, import_node_path23, import_chalk42, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main38;
+var import_promises27, import_node_fs5, import_node_readline2, import_node_path22, import_chalk42, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main38;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises28 = __toESM(require("fs/promises"));
+    import_promises27 = __toESM(require("fs/promises"));
     import_node_fs5 = require("fs");
     import_node_readline2 = require("readline");
-    import_node_path23 = __toESM(require("path"));
+    import_node_path22 = __toESM(require("path"));
     import_chalk42 = __toESM(require("chalk"));
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
@@ -28965,17 +28735,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises28.default.mkdir(import_node_path23.default.dirname(filePath), { recursive: true });
-      await import_promises28.default.writeFile(
+      await import_promises27.default.mkdir(import_node_path22.default.dirname(filePath), { recursive: true });
+      await import_promises27.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises28.default.rename(temporaryPath, filePath);
+      await import_promises27.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path23.default.resolve(options.inputPath);
+      const inputPath = import_node_path22.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -29013,7 +28783,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path23.default.resolve(
+        const outputPath = import_node_path22.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -29024,22 +28794,22 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises28.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises27.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path23.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path22.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path23.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path22.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
         if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises28.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises27.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -29052,12 +28822,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path23.default.resolve(
+        const outputPath = import_node_path22.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path23.default.resolve(options.rootDir),
+          rootDir: import_node_path22.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -29074,7 +28844,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path23.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path22.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -29134,12 +28904,12 @@ __export(serverHealth_exports, {
   main: () => main39,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process8, import_node_os3, import_node_fs6, import_args29, import_redis16, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml4, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main39;
+var import_config10, import_node_child_process7, import_node_os3, import_node_fs6, import_args29, import_redis16, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml4, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main39;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
     import_config10 = require("dotenv/config");
-    import_node_child_process8 = require("child_process");
+    import_node_child_process7 = require("child_process");
     import_node_os3 = __toESM(require("os"));
     import_node_fs6 = require("fs");
     import_args29 = __toESM(require("args"));
@@ -29176,21 +28946,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path36) => {
+    readDiskUsage = (path35) => {
       try {
-        const stats = (0, import_node_fs6.statfsSync)(path36);
+        const stats = (0, import_node_fs6.statfsSync)(path35);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path36, usedPct: null };
+          return { path: path35, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path36,
+          path: path35,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path36, usedPct: null };
+        return { path: path35, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -29255,7 +29025,7 @@ var init_serverHealth = __esm({
       }
     };
     runDiagnosticCommand = (command, args35) => {
-      const output = (0, import_node_child_process8.execFileSync)(command, args35, {
+      const output = (0, import_node_child_process7.execFileSync)(command, args35, {
         encoding: "utf8",
         timeout: 5e3,
         maxBuffer: 1024 * 1024,
@@ -32481,11 +32251,11 @@ var init_klineFeed = __esm({
 });
 
 // src/lib/signals/tickerEvaluator.ts
-var import_strategies11, import_logger9, createSignalsTickerEvaluator;
+var import_strategies10, import_logger9, createSignalsTickerEvaluator;
 var init_tickerEvaluator = __esm({
   "src/lib/signals/tickerEvaluator.ts"() {
     "use strict";
-    import_strategies11 = require("@tradejs/node/strategies");
+    import_strategies10 = require("@tradejs/node/strategies");
     import_logger9 = require("@tradejs/infra/logger");
     init_windows();
     init_runtimeLineage();
@@ -32496,7 +32266,6 @@ var init_tickerEvaluator = __esm({
     createSignalsTickerEvaluator = ({
       userName: userName3,
       makeOrders,
-      projectRoot: projectRoot15,
       context
     }) => async (symbol, instrument) => {
       const {
@@ -32568,19 +32337,12 @@ var init_tickerEvaluator = __esm({
           makeOrders
         });
         const runtimeLineage = await buildRuntimeLineage({
-          projectRoot: projectRoot15,
-          strategyName,
           strategyRevision,
           deploymentCompositionId,
           strategyPackageVersion,
           strategyDependencyVersions,
           runtimePackageVersion,
-          config: { strategyConfig },
-          runContext: {
-            connectorName: connectorName.toLowerCase(),
-            interval: String(interval4),
-            universe
-          }
+          config: { strategyConfig }
         });
         const lifecycleKey = buildSignalsStrategyLifecycleKey({
           connectorName,
@@ -32706,7 +32468,7 @@ var init_tickerEvaluator = __esm({
         if (signalRuntimeIdentity && !signal.signalId.endsWith(`:${signalRuntimeIdentity}`)) {
           signal.signalId = `${signal.signalId}:${signalRuntimeIdentity}`;
         }
-        await (0, import_strategies11.enrichSignalWithBinanceMarketContext)({ signal, env: "CRON" });
+        await (0, import_strategies10.enrichSignalWithBinanceMarketContext)({ signal, env: "CRON" });
         if (signal.orderStatus === "skipped" && typeof signal.orderSkipReason === "string" && signal.orderSkipReason.trim()) {
           recordStrategyReason(
             strategyStats,
@@ -32839,7 +32601,7 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies12, import_constants16, import_time8, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
+var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies11, import_constants16, import_time8, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
@@ -32848,7 +32610,7 @@ var init_runner = __esm({
     import_connectors16 = require("@tradejs/node/connectors");
     import_cli12 = require("@tradejs/node/cli");
     import_async5 = require("@tradejs/core/async");
-    import_strategies12 = require("@tradejs/core/strategies");
+    import_strategies11 = require("@tradejs/core/strategies");
     import_constants16 = require("@tradejs/core/constants");
     import_time8 = require("@tradejs/core/time");
     import_logger10 = require("@tradejs/infra/logger");
@@ -32906,7 +32668,7 @@ var init_runner = __esm({
       const createDefaultSignalsLifecycle = (runtimeInterval = interval4) => createSignalsStrategyLifecycle({
         intervalMs: Number(runtimeInterval) * 6e4,
         maxLiveBars: resolveSignalsDaemonMaxLiveBars(runtimeInterval),
-        releaseState: import_strategies12.releaseStrategyReplayCache
+        releaseState: import_strategies11.releaseStrategyReplayCache
       });
       const timeOperation3 = (label, operation) => timeOperation(
         label,
@@ -33258,7 +33020,6 @@ var init_runner = __esm({
           const evaluateTicker = createSignalsTickerEvaluator({
             userName: config2.userName,
             makeOrders: config2.makeOrders,
-            projectRoot: projectRoot15,
             context: {
               connectorName,
               connector: marketConnector,
@@ -33312,7 +33073,7 @@ var init_runner = __esm({
               new Map(
                 runtimeStrategies.map(({ strategyName, strategyConfig }) => [
                   strategyName,
-                  (0, import_strategies12.mapAiRuntimeFromConfig)({
+                  (0, import_strategies11.mapAiRuntimeFromConfig)({
                     AI_ENABLED: strategyConfig.AI_ENABLED,
                     AI_MODE: strategyConfig.AI_MODE,
                     MIN_AI_QUALITY: strategyConfig.MIN_AI_QUALITY
@@ -33788,12 +33549,12 @@ var init_cliConfig2 = __esm({
 });
 
 // src/lib/replay/runtimeEvidenceSource.ts
-var import_promises29, import_node_path24, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
+var import_promises28, import_node_path23, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
 var init_runtimeEvidenceSource = __esm({
   "src/lib/replay/runtimeEvidenceSource.ts"() {
     "use strict";
-    import_promises29 = __toESM(require("fs/promises"));
-    import_node_path24 = __toESM(require("path"));
+    import_promises28 = __toESM(require("fs/promises"));
+    import_node_path23 = __toESM(require("path"));
     init_runtimeLineage();
     init_runtimeEvidenceDeployment();
     asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -33824,14 +33585,15 @@ var init_runtimeEvidenceSource = __esm({
       filePath,
       projectRoot: projectRoot15
     }) => {
-      const resolvedPath = import_node_path24.default.resolve(projectRoot15, filePath);
+      const resolvedPath = import_node_path23.default.resolve(projectRoot15, filePath);
       const root = asRecord7(
-        JSON.parse(await import_promises29.default.readFile(resolvedPath, "utf8"))
+        JSON.parse(await import_promises28.default.readFile(resolvedPath, "utf8"))
       );
       const runtime = asRecord7(root?.runtime) ?? root;
       if (!root || !runtime) {
         throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
       }
+      assertCurrentRuntimeEvidenceArtifact(root);
       const rootWindow = asRecord7(root.window);
       const runtimeWindow2 = asRecord7(runtime.window);
       return {
@@ -34394,20 +34156,20 @@ var init_portfolioReplayConnector = __esm({
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
-var import_chalk46, import_progress12, import_backtest4, import_strategies13, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies14, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, strategyIncludesSymbol, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
+var import_chalk46, import_progress12, import_backtest4, import_strategies12, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies13, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, strategyIncludesSymbol, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
 var init_historicalSignalsReplay = __esm({
   "src/lib/replay/historicalSignalsReplay.ts"() {
     "use strict";
     import_chalk46 = __toESM(require("chalk"));
     import_progress12 = __toESM(require("progress"));
     import_backtest4 = require("@tradejs/core/backtest");
-    import_strategies13 = require("@tradejs/core/strategies");
+    import_strategies12 = require("@tradejs/core/strategies");
     import_time9 = require("@tradejs/core/time");
     import_logger11 = require("@tradejs/infra/logger");
     import_redis19 = require("@tradejs/infra/redis");
     import_connectors17 = require("@tradejs/node/connectors");
     import_cli13 = require("@tradejs/node/cli");
-    import_strategies14 = require("@tradejs/node/strategies");
+    import_strategies13 = require("@tradejs/node/strategies");
     import_runtimeStrategies8 = require("@tradejs/node/runtimeStrategies");
     init_cliConfig2();
     init_support();
@@ -34429,7 +34191,7 @@ var init_historicalSignalsReplay = __esm({
             strategyConfig,
             selection
           } = runtimeStrategy;
-          const strategyCreator = await (0, import_strategies14.getStrategyCreator)(
+          const strategyCreator = await (0, import_strategies13.getStrategyCreator)(
             strategyName,
             replayProjectRoot
           );
@@ -34668,8 +34430,6 @@ var init_historicalSignalsReplay = __esm({
               strategyResults
             }) => {
               const runtimeLineage = await buildRuntimeLineage({
-                projectRoot: replayProjectRoot,
-                strategyName,
                 strategyRevision,
                 deploymentCompositionId,
                 strategyPackageVersion,
@@ -34679,11 +34439,6 @@ var init_historicalSignalsReplay = __esm({
                   configId: strategyRevision,
                   strategyConfig,
                   symbolResultConfig: strategyResults?.[symbol]?.config ?? null
-                },
-                runContext: {
-                  connectorName: connectorName.toLowerCase(),
-                  interval: String(interval4),
-                  universe: preparedRun.universe ?? null
                 }
               });
               runtimeLineages.push({
@@ -34814,7 +34569,7 @@ var init_historicalSignalsReplay = __esm({
               );
               if (result && typeof result !== "string") {
                 result.runtimeLineage = strategyRuntime.runtimeLineage;
-                await (0, import_strategies14.enrichSignalWithBinanceMarketContext)({
+                await (0, import_strategies13.enrichSignalWithBinanceMarketContext)({
                   signal: result,
                   env: "PARITY"
                 });
@@ -34838,8 +34593,8 @@ var init_historicalSignalsReplay = __esm({
         }
       } finally {
         for (const keyPrefix of sharedReplayKeyPrefixes) {
-          (0, import_strategies13.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-          (0, import_strategies13.releaseStrategyReplayCache)(keyPrefix);
+          (0, import_strategies12.releaseStrategyIndicatorsReplayCache)(keyPrefix);
+          (0, import_strategies12.releaseStrategyReplayCache)(keyPrefix);
         }
       }
       const artifacts = replayConnector.getReplayArtifacts();
@@ -37106,12 +36861,12 @@ var init_runtimeComparison = __esm({
 });
 
 // src/lib/replay/outputReport.ts
-var import_promises30, import_node_path25, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
+var import_promises29, import_node_path24, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
 var init_outputReport = __esm({
   "src/lib/replay/outputReport.ts"() {
     "use strict";
-    import_promises30 = __toESM(require("fs/promises"));
-    import_node_path25 = __toESM(require("path"));
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path24 = __toESM(require("path"));
     import_data4 = require("@tradejs/core/data");
     init_support();
     formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
@@ -37351,33 +37106,20 @@ var init_outputReport = __esm({
         const existing = grouped.get(record.strategy) ?? {
           strategy: record.strategy,
           scopes: 0,
-          gitShas: /* @__PURE__ */ new Set(),
-          dirty: /* @__PURE__ */ new Set(),
-          gates: /* @__PURE__ */ new Set(),
-          configs: /* @__PURE__ */ new Set(),
-          contexts: /* @__PURE__ */ new Set()
+          deploymentCompositions: /* @__PURE__ */ new Set(),
+          strategyRevisions: /* @__PURE__ */ new Set(),
+          strategyPackages: /* @__PURE__ */ new Set(),
+          dependencySets: /* @__PURE__ */ new Set(),
+          runtimePackages: /* @__PURE__ */ new Set()
         };
         existing.scopes += 1;
-        if (record.lineage.schemaVersion === 3) {
-          existing.gitShas.add(record.lineage.deploymentCompositionId);
-          existing.dirty.add("n/a");
-          existing.gates.add("package-owned");
-          existing.configs.add(record.lineage.strategyRevision);
-          existing.contexts.add(
-            [
-              record.lineage.strategyPackageVersion,
-              record.lineage.runtimePackageVersion
-            ].join("/")
-          );
-        } else {
-          existing.gitShas.add(record.lineage.gitSha ?? "unknown");
-          existing.dirty.add(
-            record.lineage.gitDirty == null ? "unknown" : String(record.lineage.gitDirty)
-          );
-          existing.gates.add(record.lineage.gateFingerprint);
-          existing.configs.add(record.lineage.configFingerprint);
-          existing.contexts.add(record.lineage.contextFingerprint);
-        }
+        existing.deploymentCompositions.add(record.lineage.deploymentCompositionId);
+        existing.strategyRevisions.add(record.lineage.strategyRevision);
+        existing.strategyPackages.add(record.lineage.strategyPackageVersion);
+        existing.dependencySets.add(
+          Object.entries(record.lineage.strategyDependencyVersions).sort(([left], [right]) => left.localeCompare(right)).map(([name, version]) => `${name}@${version}`).join(", ")
+        );
+        existing.runtimePackages.add(record.lineage.runtimePackageVersion);
         grouped.set(record.strategy, existing);
       }
       const formatSet = (values) => {
@@ -37388,29 +37130,29 @@ var init_outputReport = __esm({
         [
           "Strategy",
           "Scopes",
-          "Git SHA",
-          "Dirty",
-          "Gate",
-          "Config variants",
-          "Context"
+          "Deployment composition",
+          "Strategy revision",
+          "Strategy package",
+          "Dependencies",
+          "Runtime package"
         ],
         [...grouped.values()].sort((left, right) => left.strategy.localeCompare(right.strategy)).map(
           ({
             strategy,
             scopes,
-            gitShas,
-            dirty,
-            gates,
-            configs,
-            contexts
+            deploymentCompositions,
+            strategyRevisions,
+            strategyPackages,
+            dependencySets,
+            runtimePackages
           }) => [
             strategy,
             scopes,
-            formatSet(gitShas),
-            formatSet(dirty),
-            formatSet(gates),
-            `${configs.size}: ${formatSet(configs)}`,
-            formatSet(contexts)
+            formatSet(deploymentCompositions),
+            formatSet(strategyRevisions),
+            formatSet(strategyPackages),
+            formatSet(dependencySets),
+            formatSet(runtimePackages)
           ]
         )
       ) : "_No replay lineage records._";
@@ -37429,8 +37171,8 @@ var init_outputReport = __esm({
       strategySnapshot,
       runtimeComparison
     }) => {
-      const outputDir = import_node_path25.default.resolve(projectRoot15, "data/replay/output");
-      await import_promises30.default.mkdir(outputDir, { recursive: true });
+      const outputDir = import_node_path24.default.resolve(projectRoot15, "data/replay/output");
+      await import_promises29.default.mkdir(outputDir, { recursive: true });
       const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
       const report = {
         reportType: "replay-output",
@@ -37465,8 +37207,8 @@ var init_outputReport = __esm({
         runtimeComparison,
         perTradeAnalysis
       };
-      const markdownPath = import_node_path25.default.join(outputDir, `${timestamp}-replay-report.md`);
-      const jsonPath = import_node_path25.default.join(outputDir, `${timestamp}-replay-report.json`);
+      const markdownPath = import_node_path24.default.join(outputDir, `${timestamp}-replay-report.md`);
+      const jsonPath = import_node_path24.default.join(outputDir, `${timestamp}-replay-report.json`);
       const lines = [
         "# Replay Report",
         "",
@@ -37532,8 +37274,8 @@ var init_outputReport = __esm({
         ""
       ];
       await Promise.all([
-        import_promises30.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-        import_promises30.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
+        import_promises29.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+        import_promises29.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
 `, "utf8")
       ]);
       return {