@tradejs/cli 3.1.27-beta.248 → 3.1.27-beta.250

package/dist/cli.js

@@ -2185,9 +2185,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path41) => (Array.isArray(path41) ? path41 : path41.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path41) => {
-      const segments = normalizeFeaturePath(path41);
+    normalizeFeaturePath = (path42) => (Array.isArray(path42) ? path42 : path42.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path42) => {
+      const segments = normalizeFeaturePath(path42);
       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 = (path41) => {
-      const segments = (Array.isArray(path41) ? path41 : path41.split(".")).filter(
+    classifyAiPocketFeaturePath = (path42) => {
+      const segments = (Array.isArray(path42) ? path42 : path42.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 = (path41) => {
-      if (path41.includes("global-metrics")) return "global";
-      if (path41.includes("cryptocurrency/quotes")) return "reference";
-      if (path41.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path41.includes("fear-and-greed")) return "fearGreed";
-      if (path41.includes("cmc100")) return "cmc100";
-      if (path41.includes("cmc20")) return "cmc20";
-      return path41;
-    };
-    recordCoinMarketCapFetchStats = (stats, path41, creditCount) => {
+    getCoinMarketCapPathLabel = (path42) => {
+      if (path42.includes("global-metrics")) return "global";
+      if (path42.includes("cryptocurrency/quotes")) return "reference";
+      if (path42.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path42.includes("fear-and-greed")) return "fearGreed";
+      if (path42.includes("cmc100")) return "cmc100";
+      if (path42.includes("cmc20")) return "cmc20";
+      return path42;
+    };
+    recordCoinMarketCapFetchStats = (stats, path42, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path41) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path42) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path41, existing);
+      stats.byPath.set(path42, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path41, item]) => `${getCoinMarketCapPathLabel(path41)}=${item.requests}req/${item.credits}cr`
+        ([path42, item]) => `${getCoinMarketCapPathLabel(path42)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -26625,12 +26625,378 @@ var init_runtimeFeedbackSync2 = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceCompositionSnapshots.ts
+var import_node_crypto13, import_promises28, import_node_path24, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord4, sha2564, safeSegment6, isExistingDestinationError4, parseManifest3, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
+var init_runtimeEvidenceCompositionSnapshots = __esm({
+  "src/lib/runtimeEvidenceCompositionSnapshots.ts"() {
+    "use strict";
+    import_node_crypto13 = require("crypto");
+    import_promises28 = __toESM(require("fs/promises"));
+    import_node_path24 = __toESM(require("path"));
+    init_runtimeEvidenceDeployment();
+    init_runtimeEvidenceProducer();
+    SNAPSHOT_FILE = "snapshot.json";
+    MANIFEST_FILE = "manifest.json";
+    COMPLETE_FILE = ".complete";
+    createRuntimeEvidenceCompositionSnapshotRecorder = ({
+      persist,
+      onError
+    }) => {
+      const completed = /* @__PURE__ */ new Set();
+      const inFlight = /* @__PURE__ */ new Set();
+      return {
+        observe(compositionId) {
+          if (completed.has(compositionId) || inFlight.has(compositionId)) return;
+          inFlight.add(compositionId);
+          void Promise.resolve().then(() => persist(compositionId)).then(() => completed.add(compositionId)).catch((error) => onError(compositionId, error)).finally(() => inFlight.delete(compositionId));
+        }
+      };
+    };
+    isRecord4 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    sha2564 = (value) => (0, import_node_crypto13.createHash)("sha256").update(value).digest("hex");
+    safeSegment6 = (value, label) => {
+      const normalized = value.trim();
+      if (!normalized || !/^[a-zA-Z0-9._:-]+$/.test(normalized)) {
+        throw new Error(`Invalid runtime evidence snapshot ${label}`);
+      }
+      return normalized;
+    };
+    isExistingDestinationError4 = (error) => {
+      const code = error.code;
+      return code === "EEXIST" || code === "ENOTEMPTY";
+    };
+    parseManifest3 = (value) => {
+      const manifest = isRecord4(value) ? value : null;
+      const payload = isRecord4(manifest?.payload) ? manifest.payload : null;
+      if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence-composition-snapshot" || typeof manifest.createdAt !== "number" || typeof manifest.userName !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.deploymentCompositionId !== "string" || payload?.file !== SNAPSHOT_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number") {
+        throw new Error("Invalid runtime evidence composition snapshot manifest");
+      }
+      return manifest;
+    };
+    verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
+      const [manifestText, payload, completeText] = await Promise.all([
+        import_promises28.default.readFile(import_node_path24.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+        import_promises28.default.readFile(import_node_path24.default.join(bundleDir, SNAPSHOT_FILE)),
+        import_promises28.default.readFile(import_node_path24.default.join(bundleDir, COMPLETE_FILE), "utf8")
+      ]);
+      const manifest = parseManifest3(JSON.parse(manifestText));
+      if (completeText.trim() !== manifest.deploymentCompositionId) {
+        throw new Error(`Invalid completion marker in ${bundleDir}`);
+      }
+      if (payload.byteLength !== manifest.payload.bytes || sha2564(payload) !== manifest.payload.sha256) {
+        throw new Error(
+          `Runtime evidence snapshot checksum mismatch in ${bundleDir}`
+        );
+      }
+      const value = JSON.parse(payload.toString("utf8"));
+      const record = isRecord4(value) ? value : null;
+      if (record?.schemaVersion !== 1 || record.reportType !== "runtime-evidence-composition-snapshot" || record.userName !== manifest.userName) {
+        throw new Error(
+          `Invalid runtime evidence snapshot payload in ${bundleDir}`
+        );
+      }
+      const deployment = parseRuntimeEvidenceDeploymentSnapshot(record.deployment);
+      const producer = parseRuntimeEvidenceProducer(record.producer);
+      if (deployment.id !== manifest.deploymentId || deployment.deploymentCompositionId !== manifest.deploymentCompositionId) {
+        throw new Error(
+          `Runtime evidence snapshot identity mismatch in ${bundleDir}`
+        );
+      }
+      return { bundleDir, deployment, producer };
+    };
+    sameSnapshot = (snapshot, deployment, producer) => JSON.stringify(snapshot.deployment) === JSON.stringify(deployment) && JSON.stringify(snapshot.producer) === JSON.stringify(producer);
+    publishRuntimeEvidenceCompositionSnapshot = async ({
+      evidenceRoot,
+      userName: userName3,
+      deployment,
+      producer
+    }) => {
+      const deploymentId = safeSegment6(deployment.id, "deployment id");
+      const compositionId = safeSegment6(
+        deployment.deploymentCompositionId,
+        "composition id"
+      );
+      const createdAt = Date.now();
+      const snapshot = {
+        schemaVersion: 1,
+        reportType: "runtime-evidence-composition-snapshot",
+        createdAt,
+        userName: userName3,
+        deployment,
+        producer
+      };
+      const payload = `${JSON.stringify(snapshot, null, 2)}
+`;
+      const manifest = {
+        schemaVersion: 1,
+        reportType: "runtime-evidence-composition-snapshot",
+        createdAt,
+        userName: userName3,
+        deploymentId,
+        deploymentCompositionId: compositionId,
+        payload: {
+          file: SNAPSHOT_FILE,
+          sha256: sha2564(payload),
+          bytes: Buffer.byteLength(payload)
+        }
+      };
+      const snapshotsRoot = import_node_path24.default.join(evidenceRoot, "snapshots", deploymentId);
+      const bundleDir = import_node_path24.default.join(snapshotsRoot, compositionId);
+      const temporaryDir = import_node_path24.default.join(
+        evidenceRoot,
+        "incoming",
+        `snapshot-${compositionId}.tmp-${(0, import_node_crypto13.randomUUID)()}`
+      );
+      await import_promises28.default.mkdir(temporaryDir, { recursive: true });
+      try {
+        await Promise.all([
+          import_promises28.default.writeFile(import_node_path24.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+          import_promises28.default.writeFile(
+            import_node_path24.default.join(temporaryDir, MANIFEST_FILE),
+            `${JSON.stringify(manifest, null, 2)}
+`,
+            "utf8"
+          )
+        ]);
+        await import_promises28.default.writeFile(
+          import_node_path24.default.join(temporaryDir, COMPLETE_FILE),
+          `${compositionId}
+`,
+          "utf8"
+        );
+        await import_promises28.default.mkdir(snapshotsRoot, { recursive: true });
+        try {
+          await import_promises28.default.rename(temporaryDir, bundleDir);
+        } catch (error) {
+          if (!isExistingDestinationError4(error)) throw error;
+          await import_promises28.default.rm(temporaryDir, { recursive: true, force: true });
+        }
+      } catch (error) {
+        await import_promises28.default.rm(temporaryDir, { recursive: true, force: true });
+        throw error;
+      }
+      const verified = await verifyRuntimeEvidenceCompositionSnapshot(bundleDir);
+      if (!sameSnapshot(verified, deployment, producer)) {
+        throw new Error(
+          `Conflicting runtime evidence snapshot for composition ${compositionId}`
+        );
+      }
+      return verified;
+    };
+    captureRuntimeEvidenceCompositionSnapshot = async ({
+      projectRoot: projectRoot17,
+      userName: userName3,
+      deploymentId,
+      expectedCompositionId
+    }) => {
+      const [deployment, producer] = await Promise.all([
+        resolveRuntimeEvidenceDeploymentSnapshot({
+          userName: userName3,
+          projectRoot: projectRoot17,
+          deploymentId
+        }),
+        resolveRuntimeEvidenceProducer({ projectRoot: projectRoot17, required: true })
+      ]);
+      if (!producer) {
+        throw new Error("Runtime evidence producer identity is required");
+      }
+      if (deployment.deploymentCompositionId !== expectedCompositionId) {
+        throw new Error(
+          `Runtime deployment composition changed while capturing snapshot: expected ${expectedCompositionId}, received ${deployment.deploymentCompositionId}`
+        );
+      }
+      await publishRuntimeEvidenceCompositionSnapshot({
+        evidenceRoot: import_node_path24.default.join(projectRoot17, "data", "runtime-evidence"),
+        userName: userName3,
+        deployment,
+        producer
+      });
+    };
+    discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
+      const rootDir = import_node_path24.default.join(evidenceRoot, "snapshots");
+      const bundleDirs = [];
+      let deployments;
+      try {
+        deployments = await import_promises28.default.readdir(rootDir, { withFileTypes: true });
+      } catch (error) {
+        if (error.code === "ENOENT") return [];
+        throw error;
+      }
+      for (const deployment of deployments.filter((entry) => entry.isDirectory())) {
+        const deploymentDir = import_node_path24.default.join(rootDir, deployment.name);
+        const compositions = await import_promises28.default.readdir(deploymentDir, {
+          withFileTypes: true
+        });
+        bundleDirs.push(
+          ...compositions.filter(
+            (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+          ).map((entry) => import_node_path24.default.join(deploymentDir, entry.name))
+        );
+      }
+      return Promise.all(
+        bundleDirs.sort().map(verifyRuntimeEvidenceCompositionSnapshot)
+      );
+    };
+  }
+});
+
+// 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_runtimeEvidenceCompositionSnapshots();
+    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 compositionSnapshots = await discoverRuntimeEvidenceCompositionSnapshots(publishRoot);
+      for (const snapshot of compositionSnapshots) {
+        if (snapshot.deployment.id !== currentDeployment.id) continue;
+        register({
+          deployment: { ...snapshot.deployment, tickers: void 0 },
+          producer: snapshot.producer
+        });
+      }
+      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 import_node_crypto14, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, buildRuntimeLineage, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
 var init_runtimeLineage = __esm({
   "src/lib/runtimeLineage.ts"() {
     "use strict";
-    import_node_crypto13 = require("crypto");
+    import_node_crypto14 = require("crypto");
     normalizeForStableJson2 = (value) => {
       if (Array.isArray(value)) {
         return value.map(normalizeForStableJson2);
@@ -26655,7 +27021,7 @@ var init_runtimeLineage = __esm({
       );
       return Number.isFinite(maxLossValue) ? maxLossValue : null;
     };
-    fingerprintRuntimeValue = (value) => (0, import_node_crypto13.createHash)("sha256").update(JSON.stringify(normalizeForStableJson2(value))).digest("hex").slice(0, 16);
+    fingerprintRuntimeValue = (value) => (0, import_node_crypto14.createHash)("sha256").update(JSON.stringify(normalizeForStableJson2(value))).digest("hex").slice(0, 16);
     buildRuntimeLineage = async ({
       strategyRevision,
       deploymentCompositionId,
@@ -26709,16 +27075,17 @@ __export(runtimeEvidence_exports, {
   main: () => main36,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises28, import_node_path24, import_args28, import_chalk41, flags27, projectRoot11, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main36;
+var import_promises29, import_node_path25, import_args28, import_chalk41, flags27, projectRoot11, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main36;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
-    import_promises28 = __toESM(require("fs/promises"));
-    import_node_path24 = __toESM(require("path"));
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path25 = __toESM(require("path"));
     import_args28 = __toESM(require("args"));
     import_chalk41 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
     init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceCompositions();
     init_runtimeLineage();
     init_runtimeEvidenceProducer();
     init_runtimeEvidenceDeployment();
@@ -26811,15 +27178,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_path25.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 +27209,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
-      };
-      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)}
+          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_path25.default.resolve(projectRoot11, String(flags27.out));
+      await import_promises29.default.mkdir(import_node_path25.default.dirname(outPath), { recursive: true });
+      await import_promises29.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_path25.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
@@ -26934,11 +27313,11 @@ __export(runtimeEvidenceSync_exports, {
   main: () => main37,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path25, import_args29, import_chalk42, flags28, projectRoot12, runtimeEvidenceSync, main37;
+var import_node_path26, import_args29, import_chalk42, flags28, projectRoot12, runtimeEvidenceSync, main37;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path25 = __toESM(require("path"));
+    import_node_path26 = __toESM(require("path"));
     import_args29 = __toESM(require("args"));
     import_chalk42 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
@@ -26966,7 +27345,7 @@ var init_runtimeEvidenceSync2 = __esm({
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path25.default.resolve(projectRoot12, String(flags28.dir));
+      const evidenceRoot = import_node_path26.default.resolve(projectRoot12, String(flags28.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
@@ -28053,7 +28432,7 @@ async function collectReleaseEvidenceReferences(references) {
       let artifact;
       try {
         const parsed = JSON.parse(
-          await import_promises29.default.readFile(reference.path, "utf8")
+          await import_promises30.default.readFile(reference.path, "utf8")
         );
         assert3(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
@@ -28200,13 +28579,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto14, import_promises29, import_node_path26, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment6, 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_crypto15, import_promises30, import_node_path27, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment7, 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_crypto14 = require("crypto");
-    import_promises29 = __toESM(require("fs/promises"));
-    import_node_path26 = __toESM(require("path"));
+    import_node_crypto15 = require("crypto");
+    import_promises30 = __toESM(require("fs/promises"));
+    import_node_path27 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
@@ -28219,17 +28598,17 @@ var init_strategyRelease = __esm({
     REQUIRED_LONG_WINDOWS = [1095, 1460, 1825];
     REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS = [365, 180, 90];
     MIN_RECENT_DIRECTION_REPAIR_EVENTS = 20;
-    safeSegment6 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
+    safeSegment7 = 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_path26.default.resolve(artifact.path);
+        const artifactPath = import_node_path27.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
-        const report = JSON.parse(await import_promises29.default.readFile(artifactPath, "utf8"));
+        const report = JSON.parse(await import_promises30.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
         );
@@ -28240,11 +28619,11 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path26.default.resolve(artifact.path);
+        const artifactPath = import_node_path27.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
-        return JSON.parse(await import_promises29.default.readFile(artifactPath, "utf8"));
+        return JSON.parse(await import_promises30.default.readFile(artifactPath, "utf8"));
       } catch {
         return null;
       }
@@ -28735,7 +29114,7 @@ var init_strategyRelease = __esm({
         maxLossValue: input.composition.maxLossValue,
         ...input.composition.directionPolicy == null ? {} : { directionPolicy: input.composition.directionPolicy }
       };
-      const compositionId = `${safeSegment6(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
+      const compositionId = `${safeSegment7(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
       const reasons = releaseReasons({ ...input, gates: evidenceGates });
       const economicFailure = reasons.some(
         (reason) => [
@@ -28757,16 +29136,16 @@ var init_strategyRelease = __esm({
         strategy: input.strategy,
         createdAt: input.createdAt,
         compositionId,
-        evidence: input.evidence.map(({ kind, artifactId, sha256: sha2564 }) => ({
+        evidence: input.evidence.map(({ kind, artifactId, sha256: sha2565 }) => ({
           kind,
           artifactId,
-          sha256: sha2564
+          sha256: sha2565
         })),
         verdict
       };
       return {
         schema: import_types9.STRATEGY_RELEASE_SCHEMA,
-        releaseId: `${safeSegment6(input.strategy, "strategy")}_${compactTimestamp2(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
+        releaseId: `${safeSegment7(input.strategy, "strategy")}_${compactTimestamp2(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
         strategy: input.strategy,
         createdAt: input.createdAt,
         composition: { ...input.composition, compositionId },
@@ -28790,7 +29169,7 @@ var init_strategyRelease = __esm({
       manifest
     });
     verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises29.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises30.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       const envelope = value;
       assert3(
         envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -28841,7 +29220,7 @@ var init_strategyRelease = __esm({
       return envelope;
     };
     verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises29.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises30.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       return (0, import_strategyReleaseEvidence2.verifyStrategyEvidenceMarkerEnvelope)(value);
     };
     releaseMarkers = (manifest) => {
@@ -28903,14 +29282,14 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises29.default.mkdir(import_node_path26.default.dirname(filePath), { recursive: true });
-      await import_promises29.default.writeFile(
+      await import_promises30.default.mkdir(import_node_path27.default.dirname(filePath), { recursive: true });
+      await import_promises30.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
 `,
         "utf8"
       );
-      await import_promises29.default.rename(temporaryPath, filePath);
+      await import_promises30.default.rename(temporaryPath, filePath);
     };
     publishStrategyRelease = async ({
       rootDir,
@@ -28927,16 +29306,16 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path26.default.join(
+      const releasePath = import_node_path27.default.join(
         rootDir,
         "releases",
-        safeSegment6(manifest.strategy, "strategy"),
+        safeSegment7(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path26.default.join(
+      const markerPath = import_node_path27.default.join(
         rootDir,
         "markers",
-        safeSegment6(manifest.strategy, "strategy"),
+        safeSegment7(manifest.strategy, "strategy"),
         `${markerEnvelope.artifactId}.json`
       );
       await Promise.all([
@@ -28956,7 +29335,7 @@ var init_strategyRelease = __esm({
       composition
     }) => {
       const diagnosisSha256 = strategyReleaseSha256(diagnosis);
-      const diagnosisId = `${safeSegment6(diagnosis.strategy, "strategy")}_${compactTimestamp2(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
+      const diagnosisId = `${safeSegment7(diagnosis.strategy, "strategy")}_${compactTimestamp2(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
       const envelope = {
         schema: "tradejs-strategy-live-diagnosis-envelope/v1",
         diagnosisId,
@@ -29013,16 +29392,16 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path26.default.join(
+      const diagnosisPath = import_node_path27.default.join(
         rootDir,
         "diagnoses",
-        safeSegment6(diagnosis.strategy, "strategy"),
+        safeSegment7(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path26.default.join(
+      const markerPath = import_node_path27.default.join(
         rootDir,
         "markers",
-        safeSegment6(diagnosis.strategy, "strategy"),
+        safeSegment7(diagnosis.strategy, "strategy"),
         `${markerEnvelope.artifactId}.json`
       );
       await Promise.all([
@@ -29209,11 +29588,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_path26.default.dirname(resultPath);
-      const manifestPath = import_node_path26.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path26.default.join(researchDir, "spec.json");
-      const manifestBytes = await import_promises29.default.readFile(manifestPath).catch(() => null);
-      const specBytes = await import_promises29.default.readFile(specPath).catch(() => null);
+      const researchDir = import_node_path27.default.dirname(resultPath);
+      const manifestPath = import_node_path27.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path27.default.join(researchDir, "spec.json");
+      const manifestBytes = await import_promises30.default.readFile(manifestPath).catch(() => null);
+      const specBytes = await import_promises30.default.readFile(specPath).catch(() => null);
       assert3(
         manifestBytes != null && specBytes != null,
         "core result must belong to a completed core research bundle"
@@ -29222,14 +29601,14 @@ var init_strategyRelease = __esm({
       const artifactHashes = manifest.artifactHashes != null && typeof manifest.artifactHashes === "object" && !Array.isArray(manifest.artifactHashes) ? manifest.artifactHashes : null;
       const parsedSpec = JSON.parse(specBytes.toString("utf8"));
       assert3(
-        manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto14.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
+        manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto15.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
         "core result is not bound by its completed core research manifest"
       );
       for (const [relativePath, expectedSha256] of Object.entries(
         artifactHashes ?? {}
       )) {
         assert3(
-          !import_node_path26.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path27.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -29237,7 +29616,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
-          import_node_path26.default.join(researchDir, relativePath)
+          import_node_path27.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -29254,13 +29633,13 @@ __export(runtimeScorecard_exports, {
   main: () => main38,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises30, import_node_crypto15, import_node_path27, import_args30, import_chalk43, flags29, projectRoot13, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main38;
+var import_promises31, import_node_crypto16, import_node_path28, import_args30, import_chalk43, flags29, projectRoot13, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main38;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
-    import_promises30 = __toESM(require("fs/promises"));
-    import_node_crypto15 = require("crypto");
-    import_node_path27 = __toESM(require("path"));
+    import_promises31 = __toESM(require("fs/promises"));
+    import_node_crypto16 = require("crypto");
+    import_node_path28 = __toESM(require("path"));
     import_args30 = __toESM(require("args"));
     import_chalk43 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
@@ -29330,15 +29709,15 @@ var init_runtimeScorecard2 = __esm({
     projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     resolveOptionalPath = (value) => {
       const raw = String(value ?? "").trim();
-      return raw ? import_node_path27.default.resolve(projectRoot13, raw) : null;
+      return raw ? import_node_path28.default.resolve(projectRoot13, raw) : null;
     };
-    readJson = async (filePath) => filePath ? JSON.parse(await import_promises30.default.readFile(filePath, "utf8")) : void 0;
+    readJson = async (filePath) => filePath ? JSON.parse(await import_promises31.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_crypto15.createHash)("sha256").update(await import_promises30.default.readFile(filePath)).digest("hex");
+    sha256File2 = async (filePath) => (0, import_node_crypto16.createHash)("sha256").update(await import_promises31.default.readFile(filePath)).digest("hex");
     loadHistoryArtifacts = async (historyDir) => {
       if (!historyDir) return [];
       const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
@@ -29409,13 +29788,13 @@ var init_runtimeScorecard2 = __esm({
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path27.default.resolve(projectRoot13, String(flags29.out));
+      const outPath = import_node_path28.default.resolve(projectRoot13, String(flags29.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises30.default.mkdir(import_node_path27.default.dirname(outPath), { recursive: true });
+      await import_promises31.default.mkdir(import_node_path28.default.dirname(outPath), { recursive: true });
       await Promise.all([
-        import_promises30.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+        import_promises31.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-        import_promises30.default.writeFile(
+        import_promises31.default.writeFile(
           markdownPath,
           formatRuntimeScorecardMarkdown(scorecard),
           "utf8"
@@ -29429,7 +29808,7 @@ var init_runtimeScorecard2 = __esm({
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
       const strategyReleaseRoot = resolveOptionalPath(flags29.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
-        await import_promises30.default.writeFile(
+        await import_promises31.default.writeFile(
           diagnosisPath,
           `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -29450,7 +29829,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path27.default.basename(sourcePath),
+                artifactId: import_node_path28.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -29461,11 +29840,11 @@ var init_runtimeScorecard2 = __esm({
       let receiptPath2 = null;
       if (flags29.markProcessed) {
         const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
-          import_node_path27.default.dirname(runtimeEvidencePath)
+          import_node_path28.default.dirname(runtimeEvidencePath)
         );
         const feedbackSource = replayEvidencePath ? await verifyRuntimeFeedbackReplaySource({
-          bundleDir: import_node_path27.default.dirname(replayEvidencePath),
-          runtimeEvidenceBundleDir: import_node_path27.default.dirname(runtimeEvidencePath)
+          bundleDir: import_node_path28.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path28.default.dirname(runtimeEvidencePath)
         }).catch((error) => {
           if (runtimeEvidenceBundle.artifact.producer) throw error;
           return null;
@@ -29476,9 +29855,9 @@ var init_runtimeScorecard2 = __esm({
           );
         }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path27.default.resolve(projectRoot13, String(flags29.evidenceDir)),
+          evidenceRoot: import_node_path28.default.resolve(projectRoot13, String(flags29.evidenceDir)),
           deploymentId: String(flags29.deployment),
-          bundleDir: import_node_path27.default.dirname(runtimeEvidencePath),
+          bundleDir: import_node_path28.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath,
           runtimeFeedback: feedbackSource ? {
             artifactId: feedbackSource.feedback.manifest.artifactId,
@@ -29675,14 +30054,14 @@ __export(strategyRelease_exports, {
   main: () => main40,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises31, import_node_fs5, import_node_readline2, import_node_path28, import_chalk44, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main40;
+var import_promises32, import_node_fs5, import_node_readline2, import_node_path29, import_chalk44, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main40;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises31 = __toESM(require("fs/promises"));
+    import_promises32 = __toESM(require("fs/promises"));
     import_node_fs5 = require("fs");
     import_node_readline2 = require("readline");
-    import_node_path28 = __toESM(require("path"));
+    import_node_path29 = __toESM(require("path"));
     import_chalk44 = __toESM(require("chalk"));
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
@@ -29695,17 +30074,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises31.default.mkdir(import_node_path28.default.dirname(filePath), { recursive: true });
-      await import_promises31.default.writeFile(
+      await import_promises32.default.mkdir(import_node_path29.default.dirname(filePath), { recursive: true });
+      await import_promises32.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises31.default.rename(temporaryPath, filePath);
+      await import_promises32.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path28.default.resolve(options.inputPath);
+      const inputPath = import_node_path29.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -29743,7 +30122,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path28.default.resolve(
+        const outputPath = import_node_path29.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -29754,22 +30133,22 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises31.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises32.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path28.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path29.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path28.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path29.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
         if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises31.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises32.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -29782,12 +30161,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path28.default.resolve(
+        const outputPath = import_node_path29.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path28.default.resolve(options.rootDir),
+          rootDir: import_node_path29.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -29804,7 +30183,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path28.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path29.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -29906,21 +30285,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path41) => {
+    readDiskUsage = (path42) => {
       try {
-        const stats = (0, import_node_fs6.statfsSync)(path41);
+        const stats = (0, import_node_fs6.statfsSync)(path42);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path41, usedPct: null };
+          return { path: path42, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path41,
+          path: path42,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path41, usedPct: null };
+        return { path: path42, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -32028,12 +32407,12 @@ __export(runtimeParity_exports, {
   main: () => main42,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto16, import_args32, import_chalk46, import_constants15, import_time9, import_logger6, import_redis17, import_cli11, import_backtest3, import_connectors14, flags30, interval3, projectRoot15, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main42;
+var import_config11, import_node_crypto17, import_args32, import_chalk46, import_constants15, import_time9, import_logger6, import_redis17, import_cli11, import_backtest3, import_connectors14, flags30, interval3, projectRoot15, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main42;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
-    import_node_crypto16 = require("crypto");
+    import_node_crypto17 = require("crypto");
     import_args32 = __toESM(require("args"));
     import_chalk46 = __toESM(require("chalk"));
     import_constants15 = require("@tradejs/core/constants");
@@ -32416,9 +32795,9 @@ var init_runtimeParity2 = __esm({
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto16.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto16.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto16.randomUUID)().slice(0, 8),
+              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto17.randomUUID)().slice(0, 8)}`,
+              testId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
+              testSuiteId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
               strategyName: target.strategy,
               strategyConfig: replayConfig,
               connectorName,
@@ -33657,6 +34036,7 @@ var init_runner = __esm({
     init_klineFeed();
     init_tickerEvaluator();
     init_configuredScopes();
+    init_runtimeEvidenceCompositionSnapshots();
     SLOW_SIGNALS_WARNING_MS = 10 * 6e4;
     formatDuration3 = (durationMs) => `${(durationMs / 1e3).toFixed(1)}s`;
     resolvePositiveInteger2 = (value, fallback) => {
@@ -33677,6 +34057,19 @@ var init_runner = __esm({
     createSignalsRunner = (config2) => {
       const interval4 = config2.interval;
       const projectRoot17 = config2.projectRoot?.trim() || String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const compositionSnapshotRecorder = process.env.TRADEJS_PROJECT_SHA && process.env.TRADEJS_PROJECT_IMAGE_DIGEST && config2.deploymentId ? createRuntimeEvidenceCompositionSnapshotRecorder({
+        persist: (compositionId) => captureRuntimeEvidenceCompositionSnapshot({
+          projectRoot: projectRoot17,
+          userName: config2.userName,
+          deploymentId: config2.deploymentId,
+          expectedCompositionId: compositionId
+        }),
+        onError: (compositionId, error) => import_logger10.logger.warn(
+          "runtime evidence snapshot unavailable; trading continues and the next cycle will retry (composition=%s): %s",
+          compositionId,
+          error instanceof Error ? error.message : String(error)
+        )
+      }) : null;
       const resolveSignalsDaemonMaxLiveBars = (runtimeInterval = interval4) => {
         const intervalMinutes = Number(runtimeInterval);
         const preloadBars = Math.ceil(
@@ -34286,6 +34679,9 @@ var init_runner = __esm({
               if (!currentDeployment) {
                 throw new Error(`Runtime deployment not found: ${deploymentId}`);
               }
+              compositionSnapshotRecorder?.observe(
+                currentDeployment.deploymentCompositionId
+              );
               const scopes = await loadConfiguredSignalsScopes(currentDeployment);
               for (const [key, staleSession] of sessions) {
                 if (scopes.has(key)) continue;
@@ -34575,12 +34971,12 @@ var init_cliConfig2 = __esm({
 });
 
 // src/lib/replay/runtimeEvidenceSource.ts
-var import_promises32, import_node_path29, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
+var import_promises33, import_node_path30, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
 var init_runtimeEvidenceSource = __esm({
   "src/lib/replay/runtimeEvidenceSource.ts"() {
     "use strict";
-    import_promises32 = __toESM(require("fs/promises"));
-    import_node_path29 = __toESM(require("path"));
+    import_promises33 = __toESM(require("fs/promises"));
+    import_node_path30 = __toESM(require("path"));
     init_runtimeLineage();
     init_runtimeEvidenceDeployment();
     asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -34611,9 +35007,9 @@ var init_runtimeEvidenceSource = __esm({
       filePath,
       projectRoot: projectRoot17
     }) => {
-      const resolvedPath = import_node_path29.default.resolve(projectRoot17, filePath);
+      const resolvedPath = import_node_path30.default.resolve(projectRoot17, filePath);
       const root = asRecord7(
-        JSON.parse(await import_promises32.default.readFile(resolvedPath, "utf8"))
+        JSON.parse(await import_promises33.default.readFile(resolvedPath, "utf8"))
       );
       const runtime = asRecord7(root?.runtime) ?? root;
       if (!root || !runtime) {
@@ -38285,12 +38681,12 @@ var init_runtimeComparison = __esm({
 });
 
 // src/lib/replay/outputReport.ts
-var import_promises33, import_node_path30, import_data6, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
+var import_promises34, import_node_path31, import_data6, 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_promises33 = __toESM(require("fs/promises"));
-    import_node_path30 = __toESM(require("path"));
+    import_promises34 = __toESM(require("fs/promises"));
+    import_node_path31 = __toESM(require("path"));
     import_data6 = require("@tradejs/core/data");
     init_support();
     formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
@@ -38595,8 +38991,8 @@ var init_outputReport = __esm({
       strategySnapshot,
       runtimeComparison
     }) => {
-      const outputDir = import_node_path30.default.resolve(projectRoot17, "data/replay/output");
-      await import_promises33.default.mkdir(outputDir, { recursive: true });
+      const outputDir = import_node_path31.default.resolve(projectRoot17, "data/replay/output");
+      await import_promises34.default.mkdir(outputDir, { recursive: true });
       const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
       const report = {
         reportType: "replay-output",
@@ -38631,8 +39027,8 @@ var init_outputReport = __esm({
         runtimeComparison,
         perTradeAnalysis
       };
-      const markdownPath = import_node_path30.default.join(outputDir, `${timestamp}-replay-report.md`);
-      const jsonPath = import_node_path30.default.join(outputDir, `${timestamp}-replay-report.json`);
+      const markdownPath = import_node_path31.default.join(outputDir, `${timestamp}-replay-report.md`);
+      const jsonPath = import_node_path31.default.join(outputDir, `${timestamp}-replay-report.json`);
       const lines = [
         "# Replay Report",
         "",
@@ -38698,8 +39094,8 @@ var init_outputReport = __esm({
         ""
       ];
       await Promise.all([
-        import_promises33.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-        import_promises33.default.writeFile(jsonPath, `${(0, import_data6.toJson)(report, true)}
+        import_promises34.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+        import_promises34.default.writeFile(jsonPath, `${(0, import_data6.toJson)(report, true)}
 `, "utf8")
       ]);
       return {