@tradejs/cli 3.1.27-beta.247 → 3.1.27-beta.249

package/dist/cli.js

@@ -26625,6 +26625,148 @@ var init_runtimeFeedbackSync2 = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceCompositions.ts
+var stableSnapshotIdentity, producerIdentity, loadRuntimeEvidenceCompositionSnapshots, rowCompositionId, rowTimestamp, belongsToSnapshot, splitRuntimeEvidenceByComposition;
+var init_runtimeEvidenceCompositions = __esm({
+  "src/lib/runtimeEvidenceCompositions.ts"() {
+    "use strict";
+    init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceDeployment();
+    init_runtimeEvidenceProducer();
+    stableSnapshotIdentity = (deployment) => JSON.stringify({ ...deployment, tickers: void 0 });
+    producerIdentity = (producer) => JSON.stringify(producer);
+    loadRuntimeEvidenceCompositionSnapshots = async ({
+      publishRoot,
+      currentDeployment,
+      currentProducer
+    }) => {
+      const snapshots = /* @__PURE__ */ new Map();
+      const register = (snapshot) => {
+        const compositionId = snapshot.deployment.deploymentCompositionId;
+        const known = snapshots.get(compositionId);
+        if (known && (stableSnapshotIdentity(known.deployment) !== stableSnapshotIdentity(snapshot.deployment) || producerIdentity(known.producer) !== producerIdentity(snapshot.producer))) {
+          throw new Error(
+            `Conflicting runtime evidence snapshot for composition ${compositionId}`
+          );
+        }
+        snapshots.set(compositionId, snapshot);
+      };
+      const bundleDirs = await discoverRuntimeEvidenceBundles(publishRoot);
+      for (const bundleDir of bundleDirs) {
+        const bundle = await verifyRuntimeEvidenceBundle(bundleDir);
+        const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+          bundle.artifact.deployment
+        );
+        if (deployment.id !== currentDeployment.id) continue;
+        if (bundle.artifact.producer == null) continue;
+        register({
+          deployment: { ...deployment, tickers: void 0 },
+          producer: parseRuntimeEvidenceProducer(bundle.artifact.producer)
+        });
+      }
+      const historicalCurrent = snapshots.get(
+        currentDeployment.deploymentCompositionId
+      );
+      if (historicalCurrent && stableSnapshotIdentity(historicalCurrent.deployment) !== stableSnapshotIdentity(currentDeployment)) {
+        throw new Error(
+          `Current runtime deployment conflicts with stored composition ${currentDeployment.deploymentCompositionId}`
+        );
+      }
+      snapshots.set(currentDeployment.deploymentCompositionId, {
+        deployment: { ...currentDeployment, tickers: void 0 },
+        producer: currentProducer
+      });
+      return snapshots;
+    };
+    rowCompositionId = (row) => row.runtimeLineage?.deploymentCompositionId ?? row.lineage?.deploymentCompositionId ?? null;
+    rowTimestamp = (row) => {
+      for (const field of [
+        "firstTimestamp",
+        "entryTimestamp",
+        "timestamp",
+        "lastTimestamp"
+      ]) {
+        const value = row[field];
+        if (typeof value === "number" && Number.isFinite(value)) return value;
+      }
+      return Number.POSITIVE_INFINITY;
+    };
+    belongsToSnapshot = (row, deployment) => {
+      const strategy = activeRuntimeEvidenceStrategies(deployment).find(
+        (candidate) => candidate.strategyName === row.strategy
+      );
+      return Boolean(
+        strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && runtimeLineageMatchesStrategySnapshot({
+          lineage: row.runtimeLineage ?? row.lineage,
+          deployment,
+          strategy
+        })
+      );
+    };
+    splitRuntimeEvidenceByComposition = ({
+      evidence,
+      snapshots,
+      includeEmptyCompositionIds = [],
+      ignoreUnknownCompositions = false
+    }) => {
+      const observed = /* @__PURE__ */ new Set();
+      for (const row of [
+        ...evidence.trades,
+        ...evidence.signals,
+        ...evidence.evaluations,
+        ...evidence.lineageScopes
+      ]) {
+        const compositionId = rowCompositionId(row);
+        if (compositionId) observed.add(compositionId);
+      }
+      for (const compositionId of includeEmptyCompositionIds) {
+        observed.add(compositionId);
+      }
+      const missing = [...observed].filter(
+        (compositionId) => !snapshots.has(compositionId)
+      );
+      if (missing.length && !ignoreUnknownCompositions) {
+        throw new Error(
+          `Runtime evidence has no verified deployment snapshot for composition(s): ${missing.sort().join(", ")}`
+        );
+      }
+      return [...observed].filter((compositionId) => snapshots.has(compositionId)).map((compositionId) => snapshots.get(compositionId)).map(({ deployment, producer }) => {
+        const trades = evidence.trades.filter(
+          (row) => belongsToSnapshot(row, deployment)
+        );
+        const signals2 = evidence.signals.filter(
+          (row) => belongsToSnapshot(row, deployment)
+        );
+        const evaluations = evidence.evaluations.filter(
+          (row) => belongsToSnapshot(row, deployment)
+        );
+        const lineageScopes = evidence.lineageScopes.filter(
+          (row) => belongsToSnapshot(row, deployment)
+        );
+        const timestamps = [
+          ...trades,
+          ...signals2,
+          ...evaluations,
+          ...lineageScopes
+        ].map((row) => rowTimestamp(row));
+        return {
+          deployment,
+          producer,
+          trades,
+          signals: signals2,
+          evaluations,
+          lineageScopes,
+          firstTimestamp: Math.min(...timestamps)
+        };
+      }).sort(
+        (left, right) => left.firstTimestamp - right.firstTimestamp || left.deployment.deploymentCompositionId.localeCompare(
+          right.deployment.deploymentCompositionId
+        )
+      );
+    };
+  }
+});
+
 // src/lib/runtimeLineage.ts
 var import_node_crypto13, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, buildRuntimeLineage, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
 var init_runtimeLineage = __esm({
@@ -26719,6 +26861,7 @@ var init_runtimeEvidence = __esm({
     import_chalk41 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
     init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceCompositions();
     init_runtimeLineage();
     init_runtimeEvidenceProducer();
     init_runtimeEvidenceDeployment();
@@ -26811,15 +26954,30 @@ var init_runtimeEvidence = __esm({
         projectRoot: projectRoot11,
         deploymentId
       });
-      const activeStrategies = activeRuntimeEvidenceStrategies(
-        deploymentSnapshot
-      ).map(({ strategyName }) => strategyName);
       const requestedStrategies = parseStrategyFilter2(flags27.strategy);
-      const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
+      const evidence = await collectRuntimeDebugEvidence({
+        userName: flags27.user,
+        startTime,
+        endTime,
+        strategies: requestedStrategies.length ? requestedStrategies : void 0,
+        deploymentId
+      });
+      const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
+        publishRoot: import_node_path24.default.resolve(projectRoot11, publishDir),
+        currentDeployment: deploymentSnapshot,
+        currentProducer: producer
+      }) : /* @__PURE__ */ new Map([
+        [
+          deploymentSnapshot.deploymentCompositionId,
+          { deployment: deploymentSnapshot, producer }
+        ]
+      ]);
       const declaredStrategies = new Set(
-        deploymentSnapshot.strategies.map(({ strategyName }) => strategyName)
+        [...snapshots.values()].flatMap(
+          ({ deployment }) => deployment.strategies.map(({ strategyName }) => strategyName)
+        )
       );
-      const unknownStrategies = strategies.filter(
+      const unknownStrategies = requestedStrategies.filter(
         (strategyName) => !declaredStrategies.has(strategyName)
       );
       if (unknownStrategies.length) {
@@ -26827,97 +26985,94 @@ var init_runtimeEvidence = __esm({
           `Strategies are not declared in ${deploymentId}: ${unknownStrategies.join(", ")}`
         );
       }
-      const evidence = await collectRuntimeDebugEvidence({
-        userName: flags27.user,
-        startTime,
-        endTime,
-        strategies,
-        deploymentId
+      const compositionRows = splitRuntimeEvidenceByComposition({
+        evidence,
+        snapshots,
+        includeEmptyCompositionIds: publishDir ? [] : [deploymentSnapshot.deploymentCompositionId],
+        ignoreUnknownCompositions: !publishDir
       });
-      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 artifacts = compositionRows.map((composition) => {
+        const strategies = activeRuntimeEvidenceStrategies(composition.deployment).map(({ strategyName }) => strategyName).filter(
+          (strategyName) => !requestedStrategies.length || requestedStrategies.includes(strategyName)
         );
-      };
-      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: flags27.user,
-        startTime,
-        endTime,
-        signals: currentSignals,
-        evaluations: currentEvaluations,
-        trades: currentTrades,
-        lineageScopes: currentLineageScopes
-      });
-      const deployment = resolveRuntimeEvidenceTickerUniverse({
-        deployment: deploymentSnapshot,
-        lineageScopes: currentLineageScopes
-      });
-      const artifact = {
-        reportType: "runtime-evidence",
-        generatedAt: Date.now(),
-        ...producer ? { producer } : {},
-        userName: flags27.user,
-        window: {
+        const runtime = buildRuntimeEvidenceReportPayload({
+          userName: flags27.user,
           startTime,
           endTime,
-          startIso: new Date(startTime).toISOString(),
-          endIso: new Date(endTime).toISOString(),
-          source
-        },
-        strategies,
-        deployment,
-        runtime
-      };
+          signals: composition.signals,
+          evaluations: composition.evaluations,
+          trades: composition.trades,
+          lineageScopes: composition.lineageScopes
+        });
+        const deployment = resolveRuntimeEvidenceTickerUniverse({
+          deployment: composition.deployment,
+          lineageScopes: composition.lineageScopes
+        });
+        return {
+          artifact: {
+            reportType: "runtime-evidence",
+            generatedAt: Date.now(),
+            ...composition.producer ? { producer: composition.producer } : {},
+            ...producer && composition.producer && composition.producer !== producer ? { collector: producer } : {},
+            userName: flags27.user,
+            window: {
+              startTime,
+              endTime,
+              startIso: new Date(startTime).toISOString(),
+              endIso: new Date(endTime).toISOString(),
+              source
+            },
+            strategies,
+            deployment,
+            runtime
+          },
+          composition
+        };
+      });
+      const current = artifacts.find(
+        ({ artifact: artifact2 }) => artifact2.deployment.deploymentCompositionId === deploymentSnapshot.deploymentCompositionId
+      ) ?? artifacts.at(-1);
+      if (!current) {
+        throw new Error("Runtime evidence window has no versioned runtime rows");
+      }
+      const artifact = current.artifact;
       const outPath = import_node_path24.default.resolve(projectRoot11, String(flags27.out));
       await import_promises28.default.mkdir(import_node_path24.default.dirname(outPath), { recursive: true });
       await import_promises28.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
-      const published = publishDir ? await publishRuntimeEvidenceBundle({
-        publishRoot: import_node_path24.default.resolve(projectRoot11, publishDir),
-        deploymentId,
-        userName: String(flags27.user),
-        startTime,
-        endTime,
-        artifact,
-        counts: artifact.runtime.counts,
-        lineageKeys: [
-          ...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;
+      const published = publishDir ? await Promise.all(
+        artifacts.map(
+          ({ artifact: artifact2, composition }) => publishRuntimeEvidenceBundle({
+            publishRoot: import_node_path24.default.resolve(projectRoot11, publishDir),
+            deploymentId,
+            userName: String(flags27.user),
+            startTime,
+            endTime,
+            artifact: artifact2,
+            counts: artifact2.runtime.counts,
+            lineageKeys: [
+              ...composition.signals.map((signal) => signal.runtimeLineage),
+              ...composition.evaluations.map(
+                (evaluation) => evaluation.runtimeLineage
+              ),
+              ...composition.trades.map((trade) => trade.runtimeLineage),
+              ...composition.lineageScopes.map((scope) => scope.lineage)
+            ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
+          })
+        )
+      ) : [];
       console.log(import_chalk41.default.green(`Wrote ${outPath}`));
-      if (published) {
-        console.log(import_chalk41.default.green(`Published ${published.bundleDir}`));
+      for (const bundle of published) {
+        console.log(import_chalk41.default.green(`Published ${bundle.bundleDir}`));
       }
       console.log(
         JSON.stringify(
           {
-            strategies: artifact.strategies,
-            runtimeCounts: artifact.runtime.counts
+            compositions: artifacts.map(({ artifact: artifact2 }) => ({
+              deploymentCompositionId: artifact2.deployment.deploymentCompositionId,
+              strategies: artifact2.strategies,
+              runtimeCounts: artifact2.runtime.counts
+            }))
           },
           null,
           2

package/dist/lib/runtimeEvidenceCompositions.js

@@ -0,0 +1,464 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeEvidenceCompositions.ts
+var runtimeEvidenceCompositions_exports = {};
+__export(runtimeEvidenceCompositions_exports, {
+  loadRuntimeEvidenceCompositionSnapshots: () => loadRuntimeEvidenceCompositionSnapshots,
+  splitRuntimeEvidenceByComposition: () => splitRuntimeEvidenceByComposition
+});
+module.exports = __toCommonJS(runtimeEvidenceCompositions_exports);
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
+  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
+);
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
+var samePackageVersions = (left, right) => {
+  if (!left || !right) return false;
+  const leftEntries = Object.entries(left).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const rightEntries = Object.entries(right).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
+};
+var runtimeLineageMatchesStrategySnapshot = ({
+  lineage,
+  deployment,
+  strategy
+}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
+  lineage.strategyDependencyVersions,
+  strategy.strategyDependencyVersions
+);
+var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
+    throw new Error(
+      "Runtime evidence deployment snapshot is missing or invalid"
+    );
+  }
+  const strategies = value.strategies.map((candidate) => {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
+      throw new Error(
+        "Runtime evidence deployment strategy snapshot is invalid"
+      );
+    }
+    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+      throw new Error(
+        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+      );
+    }
+    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+      throw new Error(
+        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+      );
+    }
+    return candidate;
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (identities.has(strategy.strategyName)) {
+      throw new Error(
+        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+      );
+    }
+    identities.add(strategy.strategyName);
+  }
+  return {
+    ...value,
+    strategies
+  };
+};
+var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
+  const record = isRecord(candidate) ? candidate : null;
+  const nested = record && isRecord(record[field]) ? record[field] : null;
+  return nested ?? record;
+}).filter((record) => record != null);
+var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
+  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
+    throw new Error("Invalid runtime evidence artifact");
+  }
+  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+    artifact.deployment
+  );
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length === 0) {
+    throw new Error("Runtime evidence deployment has no enabled strategies");
+  }
+  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
+  if (!runtime) {
+    throw new Error("Runtime evidence payload is missing");
+  }
+  if ("strategyConfigs" in runtime) {
+    throw new Error(
+      "Runtime evidence payload contains removed strategyConfigs data"
+    );
+  }
+  if ("evaluationStatsBuckets" in runtime) {
+    throw new Error(
+      "Runtime evidence payload contains removed lineage-less evaluationStatsBuckets 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;
+};
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
+var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
+var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+var assertFiniteTimestamp = (value, label) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid runtime evidence ${label}`);
+  }
+  return value;
+};
+var parseManifest = (value) => {
+  const manifest = asRecord(value);
+  const window = asRecord(manifest?.window);
+  const payload = asRecord(manifest?.payload);
+  const counts = asRecord(manifest?.counts);
+  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence" || typeof manifest.artifactId !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.userName !== "string" || typeof manifest.createdAt !== "number" || payload?.file !== RUNTIME_EVIDENCE_PAYLOAD_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Array.isArray(manifest.lineageKeys)) {
+    throw new Error("Invalid runtime evidence manifest");
+  }
+  return {
+    schemaVersion: 1,
+    artifactId: manifest.artifactId,
+    reportType: "runtime-evidence",
+    deploymentId: manifest.deploymentId,
+    userName: manifest.userName,
+    createdAt: manifest.createdAt,
+    window: {
+      startTime: assertFiniteTimestamp(window?.startTime, "window.startTime"),
+      endTime: assertFiniteTimestamp(window?.endTime, "window.endTime")
+    },
+    payload: {
+      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
+      sha256: payload.sha256,
+      bytes: payload.bytes
+    },
+    counts: Object.fromEntries(
+      Object.entries(counts ?? {}).filter(
+        (entry) => typeof entry[1] === "number" && Number.isFinite(entry[1])
+      )
+    ),
+    lineageKeys: manifest.lineageKeys.filter(
+      (value2) => typeof value2 === "string" && value2.length > 0
+    )
+  };
+};
+var verifyRuntimeEvidenceBundle = async (bundleDir) => {
+  const manifestPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_MANIFEST_FILE);
+  const payloadPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_PAYLOAD_FILE);
+  const completePath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_COMPLETE_FILE);
+  const [manifestText, payload, completeText] = await Promise.all([
+    import_promises.default.readFile(manifestPath, "utf8"),
+    import_promises.default.readFile(payloadPath),
+    import_promises.default.readFile(completePath, "utf8")
+  ]);
+  const manifest = parseManifest(JSON.parse(manifestText));
+  if (completeText.trim() !== manifest.artifactId) {
+    throw new Error(`Invalid completion marker in ${bundleDir}`);
+  }
+  if (payload.byteLength !== manifest.payload.bytes) {
+    throw new Error(`Runtime evidence size mismatch in ${bundleDir}`);
+  }
+  if (sha256(payload) !== manifest.payload.sha256) {
+    throw new Error(`Runtime evidence checksum mismatch in ${bundleDir}`);
+  }
+  const artifact = asRecord(JSON.parse(payload.toString("utf8")));
+  const artifactWindow = asRecord(artifact?.window);
+  if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
+    throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
+  }
+  const deployment = assertCurrentRuntimeEvidenceArtifact(artifact);
+  if (deployment.id !== manifest.deploymentId) {
+    throw new Error(`Runtime evidence deployment mismatch in ${bundleDir}`);
+  }
+  return {
+    bundleDir,
+    manifestPath,
+    payloadPath,
+    manifest,
+    artifact
+  };
+};
+var discoverRuntimeEvidenceBundles = async (rootDir) => {
+  const bundles = [];
+  const visit = async (directory, depth) => {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = await import_promises.default.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const names = new Set(entries.map((entry) => entry.name));
+    if (names.has(RUNTIME_EVIDENCE_MANIFEST_FILE) && names.has(RUNTIME_EVIDENCE_PAYLOAD_FILE) && names.has(RUNTIME_EVIDENCE_COMPLETE_FILE)) {
+      bundles.push(directory);
+      return;
+    }
+    await Promise.all(
+      entries.filter(
+        (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+      ).map((entry) => visit(import_node_path.default.join(directory, entry.name), depth + 1))
+    );
+  };
+  await visit(rootDir, 0);
+  return bundles.sort();
+};
+
+// src/lib/runtimeEvidenceProducer.ts
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var parseRuntimeEvidenceProducer = (value) => {
+  const producer = isRecord2(value) ? value : null;
+  const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
+  if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
+    throw new Error("Runtime evidence producer image identity is invalid");
+  }
+  return producer;
+};
+
+// src/lib/runtimeEvidenceCompositions.ts
+var stableSnapshotIdentity = (deployment) => JSON.stringify({ ...deployment, tickers: void 0 });
+var producerIdentity = (producer) => JSON.stringify(producer);
+var loadRuntimeEvidenceCompositionSnapshots = async ({
+  publishRoot,
+  currentDeployment,
+  currentProducer
+}) => {
+  const snapshots = /* @__PURE__ */ new Map();
+  const register = (snapshot) => {
+    const compositionId = snapshot.deployment.deploymentCompositionId;
+    const known = snapshots.get(compositionId);
+    if (known && (stableSnapshotIdentity(known.deployment) !== stableSnapshotIdentity(snapshot.deployment) || producerIdentity(known.producer) !== producerIdentity(snapshot.producer))) {
+      throw new Error(
+        `Conflicting runtime evidence snapshot for composition ${compositionId}`
+      );
+    }
+    snapshots.set(compositionId, snapshot);
+  };
+  const bundleDirs = await discoverRuntimeEvidenceBundles(publishRoot);
+  for (const bundleDir of bundleDirs) {
+    const bundle = await verifyRuntimeEvidenceBundle(bundleDir);
+    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+      bundle.artifact.deployment
+    );
+    if (deployment.id !== currentDeployment.id) continue;
+    if (bundle.artifact.producer == null) continue;
+    register({
+      deployment: { ...deployment, tickers: void 0 },
+      producer: parseRuntimeEvidenceProducer(bundle.artifact.producer)
+    });
+  }
+  const historicalCurrent = snapshots.get(
+    currentDeployment.deploymentCompositionId
+  );
+  if (historicalCurrent && stableSnapshotIdentity(historicalCurrent.deployment) !== stableSnapshotIdentity(currentDeployment)) {
+    throw new Error(
+      `Current runtime deployment conflicts with stored composition ${currentDeployment.deploymentCompositionId}`
+    );
+  }
+  snapshots.set(currentDeployment.deploymentCompositionId, {
+    deployment: { ...currentDeployment, tickers: void 0 },
+    producer: currentProducer
+  });
+  return snapshots;
+};
+var rowCompositionId = (row) => row.runtimeLineage?.deploymentCompositionId ?? row.lineage?.deploymentCompositionId ?? null;
+var rowTimestamp = (row) => {
+  for (const field of [
+    "firstTimestamp",
+    "entryTimestamp",
+    "timestamp",
+    "lastTimestamp"
+  ]) {
+    const value = row[field];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return Number.POSITIVE_INFINITY;
+};
+var belongsToSnapshot = (row, deployment) => {
+  const strategy = activeRuntimeEvidenceStrategies(deployment).find(
+    (candidate) => candidate.strategyName === row.strategy
+  );
+  return Boolean(
+    strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && runtimeLineageMatchesStrategySnapshot({
+      lineage: row.runtimeLineage ?? row.lineage,
+      deployment,
+      strategy
+    })
+  );
+};
+var splitRuntimeEvidenceByComposition = ({
+  evidence,
+  snapshots,
+  includeEmptyCompositionIds = [],
+  ignoreUnknownCompositions = false
+}) => {
+  const observed = /* @__PURE__ */ new Set();
+  for (const row of [
+    ...evidence.trades,
+    ...evidence.signals,
+    ...evidence.evaluations,
+    ...evidence.lineageScopes
+  ]) {
+    const compositionId = rowCompositionId(row);
+    if (compositionId) observed.add(compositionId);
+  }
+  for (const compositionId of includeEmptyCompositionIds) {
+    observed.add(compositionId);
+  }
+  const missing = [...observed].filter(
+    (compositionId) => !snapshots.has(compositionId)
+  );
+  if (missing.length && !ignoreUnknownCompositions) {
+    throw new Error(
+      `Runtime evidence has no verified deployment snapshot for composition(s): ${missing.sort().join(", ")}`
+    );
+  }
+  return [...observed].filter((compositionId) => snapshots.has(compositionId)).map((compositionId) => snapshots.get(compositionId)).map(({ deployment, producer }) => {
+    const trades = evidence.trades.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const signals = evidence.signals.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const evaluations = evidence.evaluations.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const lineageScopes = evidence.lineageScopes.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const timestamps = [
+      ...trades,
+      ...signals,
+      ...evaluations,
+      ...lineageScopes
+    ].map((row) => rowTimestamp(row));
+    return {
+      deployment,
+      producer,
+      trades,
+      signals,
+      evaluations,
+      lineageScopes,
+      firstTimestamp: Math.min(...timestamps)
+    };
+  }).sort(
+    (left, right) => left.firstTimestamp - right.firstTimestamp || left.deployment.deploymentCompositionId.localeCompare(
+      right.deployment.deploymentCompositionId
+    )
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadRuntimeEvidenceCompositionSnapshots,
+  splitRuntimeEvidenceByComposition
+});

package/dist/scripts/runtimeEvidence.js

@@ -851,35 +851,46 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
     artifact
   };
 };
-
-// src/lib/runtimeLineage.ts
-var import_node_crypto2 = require("crypto");
-var normalizeForStableJson = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeForStableJson);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+var discoverRuntimeEvidenceBundles = async (rootDir) => {
+  const bundles = [];
+  const visit = async (directory, depth) => {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = await import_promises.default.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const names = new Set(entries.map((entry) => entry.name));
+    if (names.has(RUNTIME_EVIDENCE_MANIFEST_FILE) && names.has(RUNTIME_EVIDENCE_PAYLOAD_FILE) && names.has(RUNTIME_EVIDENCE_COMPLETE_FILE)) {
+      bundles.push(directory);
+      return;
+    }
+    await Promise.all(
+      entries.filter(
+        (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+      ).map((entry) => visit(import_node_path.default.join(directory, entry.name), depth + 1))
     );
-  }
-  return value;
+  };
+  await visit(rootDir, 0);
+  return bundles.sort();
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
-var runtimeLineageKey = (lineage) => [
-  "v3",
-  lineage.deploymentCompositionId,
-  lineage.strategyRevision,
-  lineage.strategyPackageVersion,
-  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
-  lineage.runtimePackageVersion
-].join(":");
 
 // src/lib/runtimeEvidenceProducer.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto2 = require("crypto");
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
-var sha2562 = (value) => (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
+var isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var sha2562 = (value) => (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+var parseRuntimeEvidenceProducer = (value) => {
+  const producer = isRecord2(value) ? value : null;
+  const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
+  if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
+    throw new Error("Runtime evidence producer image identity is invalid");
+  }
+  return producer;
+};
 var resolveRuntimeEvidenceProducer = async ({
   projectRoot: projectRoot2,
   required
@@ -925,6 +936,162 @@ var resolveRuntimeEvidenceProducer = async ({
   };
 };
 
+// src/lib/runtimeEvidenceCompositions.ts
+var stableSnapshotIdentity = (deployment) => JSON.stringify({ ...deployment, tickers: void 0 });
+var producerIdentity = (producer) => JSON.stringify(producer);
+var loadRuntimeEvidenceCompositionSnapshots = async ({
+  publishRoot,
+  currentDeployment,
+  currentProducer
+}) => {
+  const snapshots = /* @__PURE__ */ new Map();
+  const register = (snapshot) => {
+    const compositionId = snapshot.deployment.deploymentCompositionId;
+    const known = snapshots.get(compositionId);
+    if (known && (stableSnapshotIdentity(known.deployment) !== stableSnapshotIdentity(snapshot.deployment) || producerIdentity(known.producer) !== producerIdentity(snapshot.producer))) {
+      throw new Error(
+        `Conflicting runtime evidence snapshot for composition ${compositionId}`
+      );
+    }
+    snapshots.set(compositionId, snapshot);
+  };
+  const bundleDirs = await discoverRuntimeEvidenceBundles(publishRoot);
+  for (const bundleDir of bundleDirs) {
+    const bundle = await verifyRuntimeEvidenceBundle(bundleDir);
+    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+      bundle.artifact.deployment
+    );
+    if (deployment.id !== currentDeployment.id) continue;
+    if (bundle.artifact.producer == null) continue;
+    register({
+      deployment: { ...deployment, tickers: void 0 },
+      producer: parseRuntimeEvidenceProducer(bundle.artifact.producer)
+    });
+  }
+  const historicalCurrent = snapshots.get(
+    currentDeployment.deploymentCompositionId
+  );
+  if (historicalCurrent && stableSnapshotIdentity(historicalCurrent.deployment) !== stableSnapshotIdentity(currentDeployment)) {
+    throw new Error(
+      `Current runtime deployment conflicts with stored composition ${currentDeployment.deploymentCompositionId}`
+    );
+  }
+  snapshots.set(currentDeployment.deploymentCompositionId, {
+    deployment: { ...currentDeployment, tickers: void 0 },
+    producer: currentProducer
+  });
+  return snapshots;
+};
+var rowCompositionId = (row) => row.runtimeLineage?.deploymentCompositionId ?? row.lineage?.deploymentCompositionId ?? null;
+var rowTimestamp = (row) => {
+  for (const field of [
+    "firstTimestamp",
+    "entryTimestamp",
+    "timestamp",
+    "lastTimestamp"
+  ]) {
+    const value = row[field];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return Number.POSITIVE_INFINITY;
+};
+var belongsToSnapshot = (row, deployment) => {
+  const strategy = activeRuntimeEvidenceStrategies(deployment).find(
+    (candidate) => candidate.strategyName === row.strategy
+  );
+  return Boolean(
+    strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && runtimeLineageMatchesStrategySnapshot({
+      lineage: row.runtimeLineage ?? row.lineage,
+      deployment,
+      strategy
+    })
+  );
+};
+var splitRuntimeEvidenceByComposition = ({
+  evidence,
+  snapshots,
+  includeEmptyCompositionIds = [],
+  ignoreUnknownCompositions = false
+}) => {
+  const observed = /* @__PURE__ */ new Set();
+  for (const row of [
+    ...evidence.trades,
+    ...evidence.signals,
+    ...evidence.evaluations,
+    ...evidence.lineageScopes
+  ]) {
+    const compositionId = rowCompositionId(row);
+    if (compositionId) observed.add(compositionId);
+  }
+  for (const compositionId of includeEmptyCompositionIds) {
+    observed.add(compositionId);
+  }
+  const missing = [...observed].filter(
+    (compositionId) => !snapshots.has(compositionId)
+  );
+  if (missing.length && !ignoreUnknownCompositions) {
+    throw new Error(
+      `Runtime evidence has no verified deployment snapshot for composition(s): ${missing.sort().join(", ")}`
+    );
+  }
+  return [...observed].filter((compositionId) => snapshots.has(compositionId)).map((compositionId) => snapshots.get(compositionId)).map(({ deployment, producer }) => {
+    const trades = evidence.trades.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const signals = evidence.signals.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const evaluations = evidence.evaluations.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const lineageScopes = evidence.lineageScopes.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const timestamps = [
+      ...trades,
+      ...signals,
+      ...evaluations,
+      ...lineageScopes
+    ].map((row) => rowTimestamp(row));
+    return {
+      deployment,
+      producer,
+      trades,
+      signals,
+      evaluations,
+      lineageScopes,
+      firstTimestamp: Math.min(...timestamps)
+    };
+  }).sort(
+    (left, right) => left.firstTimestamp - right.firstTimestamp || left.deployment.deploymentCompositionId.localeCompare(
+      right.deployment.deploymentCompositionId
+    )
+  );
+};
+
+// src/lib/runtimeLineage.ts
+var import_node_crypto3 = require("crypto");
+var normalizeForStableJson = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeForStableJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+    );
+  }
+  return value;
+};
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var runtimeLineageKey = (lineage) => [
+  "v3",
+  lineage.deploymentCompositionId,
+  lineage.strategyRevision,
+  lineage.strategyPackageVersion,
+  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
+  lineage.runtimePackageVersion
+].join(":");
+
 // src/scripts/runtimeEvidence.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -1015,15 +1182,30 @@ var runtimeEvidence = async () => {
     projectRoot,
     deploymentId
   });
-  const activeStrategies = activeRuntimeEvidenceStrategies(
-    deploymentSnapshot
-  ).map(({ strategyName }) => strategyName);
   const requestedStrategies = parseStrategyFilter(flags.strategy);
-  const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
+  const evidence = await collectRuntimeDebugEvidence({
+    userName: flags.user,
+    startTime,
+    endTime,
+    strategies: requestedStrategies.length ? requestedStrategies : void 0,
+    deploymentId
+  });
+  const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
+    publishRoot: import_node_path3.default.resolve(projectRoot, publishDir),
+    currentDeployment: deploymentSnapshot,
+    currentProducer: producer
+  }) : /* @__PURE__ */ new Map([
+    [
+      deploymentSnapshot.deploymentCompositionId,
+      { deployment: deploymentSnapshot, producer }
+    ]
+  ]);
   const declaredStrategies = new Set(
-    deploymentSnapshot.strategies.map(({ strategyName }) => strategyName)
+    [...snapshots.values()].flatMap(
+      ({ deployment }) => deployment.strategies.map(({ strategyName }) => strategyName)
+    )
   );
-  const unknownStrategies = strategies.filter(
+  const unknownStrategies = requestedStrategies.filter(
     (strategyName) => !declaredStrategies.has(strategyName)
   );
   if (unknownStrategies.length) {
@@ -1031,97 +1213,94 @@ var runtimeEvidence = async () => {
       `Strategies are not declared in ${deploymentId}: ${unknownStrategies.join(", ")}`
     );
   }
-  const evidence = await collectRuntimeDebugEvidence({
-    userName: flags.user,
-    startTime,
-    endTime,
-    strategies,
-    deploymentId
+  const compositionRows = splitRuntimeEvidenceByComposition({
+    evidence,
+    snapshots,
+    includeEmptyCompositionIds: publishDir ? [] : [deploymentSnapshot.deploymentCompositionId],
+    ignoreUnknownCompositions: !publishDir
   });
-  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 artifacts = compositionRows.map((composition) => {
+    const strategies = activeRuntimeEvidenceStrategies(composition.deployment).map(({ strategyName }) => strategyName).filter(
+      (strategyName) => !requestedStrategies.length || requestedStrategies.includes(strategyName)
     );
-  };
-  const currentSignals = evidence.signals.filter(belongsToCurrentDeployment);
-  const currentEvaluations = evidence.evaluations.filter(
-    belongsToCurrentDeployment
-  );
-  const currentTrades = evidence.trades.filter(belongsToCurrentDeployment);
-  const currentLineageScopes = evidence.lineageScopes.filter(
-    (scope) => belongsToCurrentDeployment({
-      ...scope,
-      runtimeLineage: scope.lineage
-    })
-  );
-  const runtime = buildRuntimeEvidenceReportPayload({
-    userName: flags.user,
-    startTime,
-    endTime,
-    signals: currentSignals,
-    evaluations: currentEvaluations,
-    trades: currentTrades,
-    lineageScopes: currentLineageScopes
-  });
-  const deployment = resolveRuntimeEvidenceTickerUniverse({
-    deployment: deploymentSnapshot,
-    lineageScopes: currentLineageScopes
-  });
-  const artifact = {
-    reportType: "runtime-evidence",
-    generatedAt: Date.now(),
-    ...producer ? { producer } : {},
-    userName: flags.user,
-    window: {
+    const runtime = buildRuntimeEvidenceReportPayload({
+      userName: flags.user,
       startTime,
       endTime,
-      startIso: new Date(startTime).toISOString(),
-      endIso: new Date(endTime).toISOString(),
-      source
-    },
-    strategies,
-    deployment,
-    runtime
-  };
+      signals: composition.signals,
+      evaluations: composition.evaluations,
+      trades: composition.trades,
+      lineageScopes: composition.lineageScopes
+    });
+    const deployment = resolveRuntimeEvidenceTickerUniverse({
+      deployment: composition.deployment,
+      lineageScopes: composition.lineageScopes
+    });
+    return {
+      artifact: {
+        reportType: "runtime-evidence",
+        generatedAt: Date.now(),
+        ...composition.producer ? { producer: composition.producer } : {},
+        ...producer && composition.producer && composition.producer !== producer ? { collector: producer } : {},
+        userName: flags.user,
+        window: {
+          startTime,
+          endTime,
+          startIso: new Date(startTime).toISOString(),
+          endIso: new Date(endTime).toISOString(),
+          source
+        },
+        strategies,
+        deployment,
+        runtime
+      },
+      composition
+    };
+  });
+  const current = artifacts.find(
+    ({ artifact: artifact2 }) => artifact2.deployment.deploymentCompositionId === deploymentSnapshot.deploymentCompositionId
+  ) ?? artifacts.at(-1);
+  if (!current) {
+    throw new Error("Runtime evidence window has no versioned runtime rows");
+  }
+  const artifact = current.artifact;
   const outPath = import_node_path3.default.resolve(projectRoot, String(flags.out));
   await import_promises3.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
   await import_promises3.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
-  const published = publishDir ? await publishRuntimeEvidenceBundle({
-    publishRoot: import_node_path3.default.resolve(projectRoot, publishDir),
-    deploymentId,
-    userName: String(flags.user),
-    startTime,
-    endTime,
-    artifact,
-    counts: artifact.runtime.counts,
-    lineageKeys: [
-      ...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;
+  const published = publishDir ? await Promise.all(
+    artifacts.map(
+      ({ artifact: artifact2, composition }) => publishRuntimeEvidenceBundle({
+        publishRoot: import_node_path3.default.resolve(projectRoot, publishDir),
+        deploymentId,
+        userName: String(flags.user),
+        startTime,
+        endTime,
+        artifact: artifact2,
+        counts: artifact2.runtime.counts,
+        lineageKeys: [
+          ...composition.signals.map((signal) => signal.runtimeLineage),
+          ...composition.evaluations.map(
+            (evaluation) => evaluation.runtimeLineage
+          ),
+          ...composition.trades.map((trade) => trade.runtimeLineage),
+          ...composition.lineageScopes.map((scope) => scope.lineage)
+        ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
+      })
+    )
+  ) : [];
   console.log(import_chalk.default.green(`Wrote ${outPath}`));
-  if (published) {
-    console.log(import_chalk.default.green(`Published ${published.bundleDir}`));
+  for (const bundle of published) {
+    console.log(import_chalk.default.green(`Published ${bundle.bundleDir}`));
   }
   console.log(
     JSON.stringify(
       {
-        strategies: artifact.strategies,
-        runtimeCounts: artifact.runtime.counts
+        compositions: artifacts.map(({ artifact: artifact2 }) => ({
+          deploymentCompositionId: artifact2.deployment.deploymentCompositionId,
+          strategies: artifact2.strategies,
+          runtimeCounts: artifact2.runtime.counts
+        }))
       },
       null,
       2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.27-beta.247",
+  "version": "3.1.27-beta.249",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -36,13 +36,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.27-beta.247",
-    "@tradejs/core": "^3.1.27-beta.247",
-    "@tradejs/indicators": "^3.1.27-beta.247",
-    "@tradejs/infra": "^3.1.27-beta.247",
-    "@tradejs/node": "^3.1.27-beta.247",
+    "@tradejs/connectors": "^3.1.27-beta.249",
+    "@tradejs/core": "^3.1.27-beta.249",
+    "@tradejs/indicators": "^3.1.27-beta.249",
+    "@tradejs/infra": "^3.1.27-beta.249",
+    "@tradejs/node": "^3.1.27-beta.249",
     "@tradejs/strategy-kit": "3.0.4",
-    "@tradejs/types": "^3.1.27-beta.247",
+    "@tradejs/types": "^3.1.27-beta.249",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",