@tradejs/cli 3.1.8 → 3.1.9-beta.214

package/dist/cli.js

@@ -12181,114 +12181,6 @@ var init_marketContextPrepare = __esm({
   }
 });
 
-// src/lib/timeWindow.ts
-var ONE_DAY_MS, toEpochMs, toPositiveNumber, resolveTimeWindow;
-var init_timeWindow = __esm({
-  "src/lib/timeWindow.ts"() {
-    "use strict";
-    ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-    toEpochMs = (value) => {
-      if (value == null || value === "") {
-        return null;
-      }
-      const parsed = Number(value);
-      if (!Number.isFinite(parsed) || parsed <= 0) {
-        return null;
-      }
-      return parsed < 1e12 ? Math.trunc(parsed * 1e3) : Math.trunc(parsed);
-    };
-    toPositiveNumber = (value) => {
-      if (value == null || value === "") {
-        return null;
-      }
-      const parsed = Number(value);
-      if (!Number.isFinite(parsed) || parsed <= 0) {
-        return null;
-      }
-      return parsed;
-    };
-    resolveTimeWindow = ({
-      days,
-      startTime,
-      endTime,
-      nowMs = Date.now(),
-      defaultStartMs,
-      defaultEndMs,
-      closedIntervalMs
-    }) => {
-      const explicitStart = toEpochMs(startTime);
-      const explicitEnd = toEpochMs(endTime);
-      const resolvedDays = toPositiveNumber(days);
-      const alignToLastClosedInterval = (window, preserveDuration) => {
-        if (typeof closedIntervalMs !== "number" || !Number.isFinite(closedIntervalMs) || closedIntervalMs <= 0) {
-          return window;
-        }
-        const alignedEnd = Math.floor(window.end / closedIntervalMs) * closedIntervalMs - 1;
-        const delta = window.end - alignedEnd;
-        const alignedStart = preserveDuration ? window.start - delta : window.start;
-        if (alignedStart >= alignedEnd) {
-          throw new Error(
-            `Invalid closed-candle window: start (${alignedStart}) must be less than end (${alignedEnd})`
-          );
-        }
-        return {
-          ...window,
-          start: Math.trunc(alignedStart),
-          end: Math.trunc(alignedEnd)
-        };
-      };
-      if (explicitStart != null || explicitEnd != null) {
-        const resolvedStart = explicitStart ?? (resolvedDays != null && explicitEnd != null ? explicitEnd - resolvedDays * ONE_DAY_MS : defaultStartMs);
-        const resolvedEnd2 = explicitEnd ?? (resolvedDays != null && explicitStart != null ? explicitStart + resolvedDays * ONE_DAY_MS : defaultEndMs ?? nowMs);
-        if (resolvedStart >= resolvedEnd2) {
-          throw new Error(
-            `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
-          );
-        }
-        return alignToLastClosedInterval(
-          {
-            start: resolvedStart,
-            end: resolvedEnd2,
-            source: "explicit"
-          },
-          explicitStart == null && resolvedDays != null
-        );
-      }
-      if (resolvedDays != null) {
-        const resolvedEnd2 = defaultEndMs ?? nowMs;
-        const resolvedStart = resolvedEnd2 - resolvedDays * ONE_DAY_MS;
-        if (resolvedStart >= resolvedEnd2) {
-          throw new Error(
-            `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
-          );
-        }
-        return alignToLastClosedInterval(
-          {
-            start: Math.trunc(resolvedStart),
-            end: Math.trunc(resolvedEnd2),
-            source: "days"
-          },
-          true
-        );
-      }
-      const resolvedEnd = defaultEndMs ?? nowMs;
-      if (defaultStartMs >= resolvedEnd) {
-        throw new Error(
-          `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
-        );
-      }
-      return alignToLastClosedInterval(
-        {
-          start: Math.trunc(defaultStartMs),
-          end: Math.trunc(resolvedEnd),
-          source: "default"
-        },
-        true
-      );
-    };
-  }
-});
-
 // src/lib/runtimeRedis.ts
 var import_redis4, import_time, import_runtimeStrategyConfigs, isRuntimeStrategyEnabled, isRuntimeTradeRecord, loadRuntimeTrades, loadRuntimeClosedTrades, loadRuntimeActiveTradeOrderIds, loadStrategyResultSymbols;
 var init_runtimeRedis = __esm({
@@ -12433,6 +12325,114 @@ var init_runtimeStrategyBacktest = __esm({
   }
 });
 
+// src/lib/timeWindow.ts
+var ONE_DAY_MS, toEpochMs, toPositiveNumber, resolveTimeWindow;
+var init_timeWindow = __esm({
+  "src/lib/timeWindow.ts"() {
+    "use strict";
+    ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+    toEpochMs = (value) => {
+      if (value == null || value === "") {
+        return null;
+      }
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        return null;
+      }
+      return parsed < 1e12 ? Math.trunc(parsed * 1e3) : Math.trunc(parsed);
+    };
+    toPositiveNumber = (value) => {
+      if (value == null || value === "") {
+        return null;
+      }
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        return null;
+      }
+      return parsed;
+    };
+    resolveTimeWindow = ({
+      days,
+      startTime,
+      endTime,
+      nowMs = Date.now(),
+      defaultStartMs,
+      defaultEndMs,
+      closedIntervalMs
+    }) => {
+      const explicitStart = toEpochMs(startTime);
+      const explicitEnd = toEpochMs(endTime);
+      const resolvedDays = toPositiveNumber(days);
+      const alignToLastClosedInterval = (window, preserveDuration) => {
+        if (typeof closedIntervalMs !== "number" || !Number.isFinite(closedIntervalMs) || closedIntervalMs <= 0) {
+          return window;
+        }
+        const alignedEnd = Math.floor(window.end / closedIntervalMs) * closedIntervalMs - 1;
+        const delta = window.end - alignedEnd;
+        const alignedStart = preserveDuration ? window.start - delta : window.start;
+        if (alignedStart >= alignedEnd) {
+          throw new Error(
+            `Invalid closed-candle window: start (${alignedStart}) must be less than end (${alignedEnd})`
+          );
+        }
+        return {
+          ...window,
+          start: Math.trunc(alignedStart),
+          end: Math.trunc(alignedEnd)
+        };
+      };
+      if (explicitStart != null || explicitEnd != null) {
+        const resolvedStart = explicitStart ?? (resolvedDays != null && explicitEnd != null ? explicitEnd - resolvedDays * ONE_DAY_MS : defaultStartMs);
+        const resolvedEnd2 = explicitEnd ?? (resolvedDays != null && explicitStart != null ? explicitStart + resolvedDays * ONE_DAY_MS : defaultEndMs ?? nowMs);
+        if (resolvedStart >= resolvedEnd2) {
+          throw new Error(
+            `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
+          );
+        }
+        return alignToLastClosedInterval(
+          {
+            start: resolvedStart,
+            end: resolvedEnd2,
+            source: "explicit"
+          },
+          explicitStart == null && resolvedDays != null
+        );
+      }
+      if (resolvedDays != null) {
+        const resolvedEnd2 = defaultEndMs ?? nowMs;
+        const resolvedStart = resolvedEnd2 - resolvedDays * ONE_DAY_MS;
+        if (resolvedStart >= resolvedEnd2) {
+          throw new Error(
+            `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
+          );
+        }
+        return alignToLastClosedInterval(
+          {
+            start: Math.trunc(resolvedStart),
+            end: Math.trunc(resolvedEnd2),
+            source: "days"
+          },
+          true
+        );
+      }
+      const resolvedEnd = defaultEndMs ?? nowMs;
+      if (defaultStartMs >= resolvedEnd) {
+        throw new Error(
+          `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
+        );
+      }
+      return alignToLastClosedInterval(
+        {
+          start: Math.trunc(defaultStartMs),
+          end: Math.trunc(resolvedEnd),
+          source: "default"
+        },
+        true
+      );
+    };
+  }
+});
+
 // src/lib/marketData/historyPrepare.ts
 var import_chalk11, import_connectors3, import_cli2, import_connectors4, withPrimaryMarketReferenceSymbols, loadBtcReferenceConnectors, updateMarketHistoryWithBtcReferences, updatePrimaryMarketHistory, updateBtcReferenceHistory;
 var init_historyPrepare = __esm({
@@ -12689,7 +12689,7 @@ var init_tickerUniverseCache = __esm({
 });
 
 // src/lib/runEnvironment.ts
-var import_chalk12, import_connectors5, import_cli4, import_constants6, import_time2, timeOperation2, resolveBacktestExecutionPreloadInterval, resolveRunConnectorName, loadReplayStrategies, prepareRunEnvironment;
+var import_chalk12, import_connectors5, import_cli4, import_constants6, import_time2, import_runtimeStrategies, timeOperation2, resolveBacktestExecutionPreloadInterval, resolveRunConnectorName, loadDeploymentReplayStrategies, prepareRunEnvironment;
 var init_runEnvironment = __esm({
   "src/lib/runEnvironment.ts"() {
     "use strict";
@@ -12698,8 +12698,9 @@ var init_runEnvironment = __esm({
     import_cli4 = require("@tradejs/node/cli");
     import_constants6 = require("@tradejs/core/constants");
     import_time2 = require("@tradejs/core/time");
-    init_timeWindow();
+    import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
     init_runtimeStrategyBacktest();
+    init_timeWindow();
     init_runFormatting();
     init_historyPrepare();
     init_tickerUniverseCache();
@@ -12733,17 +12734,43 @@ var init_runEnvironment = __esm({
       );
       return import_connectors5.DEFAULT_CONNECTOR_NAME;
     };
-    loadReplayStrategies = async (userName3) => {
-      const runtimeStrategies = await loadRuntimeStrategyBacktestConfigs(userName3);
-      if (!runtimeStrategies.length) {
+    loadDeploymentReplayStrategies = async ({
+      userName: userName3,
+      projectRoot: projectRoot15,
+      deploymentId
+    }) => {
+      const [deployment, runtimeStrategies] = await Promise.all([
+        (0, import_runtimeStrategies.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot15, deploymentId }),
+        (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot15, deploymentId })
+      ]);
+      if (!deployment) {
+        throw new Error(`Runtime deployment not found: ${deploymentId}`);
+      }
+      const strategies = deployment.enabled ? runtimeStrategies.filter((strategy) => strategy.enabled).map(
+        ({
+          strategyName,
+          version,
+          strategyPackage,
+          strategyPackageVersion,
+          runtimePackageVersion,
+          sourceStrategyConfig
+        }) => ({
+          strategyName,
+          version,
+          strategyPackage,
+          strategyPackageVersion,
+          runtimePackageVersion,
+          strategyConfig: sourceStrategyConfig
+        })
+      ) : [];
+      if (!strategies.length) {
         console.log(
           import_chalk12.default.yellow(
-            `No active runtime strategy configs found by users:${userName3}:strategies:*:config`
+            `No enabled strategies found in runtime deployment ${deploymentId}`
           )
         );
-        return [];
       }
-      return runtimeStrategies;
+      return { deployment, strategies };
     };
     prepareRunEnvironment = async ({
       connector,
@@ -13460,7 +13487,7 @@ var init_workerPool = __esm({
 });
 
 // src/lib/backtest/runnerCore.ts
-var import_fs, import_path5, import_chalk14, import_backtest, import_constants8, import_time3, import_backtestArtifacts, import_redis6, import_runtimeStrategies, import_types4, formatWindowDays, getResultAmount, getResultNetProfit2, recordError, insertTopResult, updateTopResults, updateBestTickerResult, chunkTestSuiteBySymbol, mergePersistedTestSummaries, getLogsById, resolveResultArtifacts, setTestData, persistTestSummariesIndex, validateBacktestRuntimeDeployment, prepareRunEnvironment2, buildPreparedTestSuite, trackTopResult, buildRunIntroLines, resolveTesterWorker, executeTestSuite, printRunOutro;
+var import_fs, import_path5, import_chalk14, import_backtest, import_constants8, import_time3, import_backtestArtifacts, import_redis6, import_runtimeStrategies2, import_types4, formatWindowDays, getResultAmount, getResultNetProfit2, recordError, insertTopResult, updateTopResults, updateBestTickerResult, chunkTestSuiteBySymbol, mergePersistedTestSummaries, getLogsById, resolveResultArtifacts, setTestData, persistTestSummariesIndex, validateBacktestRuntimeDeployment, prepareRunEnvironment2, buildPreparedTestSuite, trackTopResult, buildRunIntroLines, resolveTesterWorker, executeTestSuite, printRunOutro;
 var init_runnerCore = __esm({
   "src/lib/backtest/runnerCore.ts"() {
     "use strict";
@@ -13472,7 +13499,7 @@ var init_runnerCore = __esm({
     import_time3 = require("@tradejs/core/time");
     import_backtestArtifacts = require("@tradejs/infra/backtestArtifacts");
     import_redis6 = require("@tradejs/infra/redis");
-    import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
     import_types4 = require("@tradejs/types");
     init_runFormatting();
     init_marketContextPrepare();
@@ -13680,7 +13707,7 @@ var init_runnerCore = __esm({
     };
     prepareRunEnvironment2 = async () => {
       const deployment = validateBacktestRuntimeDeployment({
-        deployment: flags5.deployment ? await (0, import_runtimeStrategies.getRuntimeDeployment)({
+        deployment: flags5.deployment ? await (0, import_runtimeStrategies2.getRuntimeDeployment)({
           userName,
           projectRoot: projectRoot3,
           deploymentId: String(flags5.deployment)
@@ -24177,13 +24204,17 @@ var init_runtimeSignalsLoader = __esm({
         return null;
       }
       const suffix = key.slice(prefix.length);
-      const firstColon = suffix.indexOf(":");
-      if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+      const parts = suffix.split(":");
+      if (parts.length < 2 || parts.some((part) => !part)) {
         return null;
       }
+      const [dayKey, ...scopeParts] = parts;
+      const strategy = scopeParts.at(-1);
+      if (!dayKey || !strategy) return null;
       return {
-        dayKey: suffix.slice(0, firstColon),
-        strategy: suffix.slice(firstColon + 1)
+        dayKey,
+        ...scopeParts.length > 1 ? { deploymentId: scopeParts.slice(0, -1).join(":") } : {},
+        strategy
       };
     };
     loadRuntimeSignalEvaluationStatsBuckets = async (userName3) => {
@@ -24255,7 +24286,8 @@ var init_runtimeDebugEvidence = __esm({
       userName: userName3,
       startTime,
       endTime,
-      strategies
+      strategies,
+      deploymentId
     }) => {
       const dayKeys = (0, import_time6.getRuntimeStorageDayKeys)(startTime, endTime);
       const dayKeySet = new Set(dayKeys);
@@ -24265,6 +24297,7 @@ var init_runtimeDebugEvidence = __esm({
         signals2,
         evaluations,
         evaluationStatsBuckets,
+        lineageScopes,
         configs
       ] = await Promise.all([
         loadRuntimeTrades(userName3, { startTime, endTime }),
@@ -24272,6 +24305,7 @@ var init_runtimeDebugEvidence = __esm({
         loadRuntimeSignals(userName3, { startTime, endTime }),
         loadRuntimeSignalEvaluations(userName3, { startTime, endTime }),
         loadRuntimeSignalEvaluationStatsBuckets(userName3),
+        loadRuntimeLineageScopes(userName3, { startTime, endTime }),
         (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName3)
       ]);
       const tradesByOrderId = new Map(
@@ -24284,15 +24318,21 @@ var init_runtimeDebugEvidence = __esm({
         (left, right) => left.entryTimestamp - right.entryTimestamp
       );
       const filteredStats = evaluationStatsBuckets.filter(
-        (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
+        (entry) => dayKeySet.has(entry.dayKey) && (!deploymentId || entry.deploymentId === deploymentId) && (!strategies?.length || strategies.includes(entry.strategy))
       );
+      const matchesDeployment = (value) => !deploymentId || value.deploymentId === deploymentId;
       return {
         dayKeys,
-        trades: filterByStrategies(trades, strategies),
-        signals: filterByStrategies(signals2, strategies),
-        evaluations: filterByStrategies(evaluations, strategies),
+        trades: filterByStrategies(trades, strategies).filter(matchesDeployment),
+        signals: filterByStrategies(signals2, strategies).filter(matchesDeployment),
+        evaluations: filterByStrategies(evaluations, strategies).filter(
+          matchesDeployment
+        ),
         evaluationStatsBuckets: filteredStats,
-        strategyConfigs: configs.filter(
+        lineageScopes: lineageScopes.filter(matchesDeployment).filter(
+          (scope) => !strategies?.length || strategies.includes(scope.strategy)
+        ),
+        strategyConfigs: deploymentId ? [] : configs.filter(
           (config2) => !strategies?.length || strategies.includes(config2.strategyName)
         )
       };
@@ -24305,7 +24345,8 @@ var init_runtimeDebugEvidence = __esm({
       evaluations,
       trades,
       strategyConfigs,
-      evaluationStatsBuckets
+      evaluationStatsBuckets,
+      lineageScopes
     }) => {
       const signalById = new Map(
         signals2.map((signal) => [signal.signalId, signal])
@@ -24433,6 +24474,7 @@ var init_runtimeDebugEvidence = __esm({
           signals: signals2.length,
           evaluations: reportEvaluations.length,
           evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+          lineageScopes: lineageScopes?.length ?? 0,
           strategyConfigs: strategyConfigs?.length ?? 0
         },
         trades: debugTrades,
@@ -24456,6 +24498,7 @@ var init_runtimeDebugEvidence = __esm({
           evaluation
         })),
         evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+        lineageScopes: lineageScopes ?? [],
         strategyConfigs: strategyConfigs ?? []
       };
     };
@@ -24467,7 +24510,8 @@ var init_runtimeDebugEvidence = __esm({
       evaluations,
       trades,
       strategyConfigs,
-      evaluationStatsBuckets
+      evaluationStatsBuckets,
+      lineageScopes
     }) => ({
       reportType: "runtime-daily-evidence",
       generatedAt: Date.now(),
@@ -24484,12 +24528,14 @@ var init_runtimeDebugEvidence = __esm({
         signals: signals2.length,
         evaluations: evaluations.length,
         evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+        lineageScopes: lineageScopes?.length ?? 0,
         strategyConfigs: strategyConfigs?.length ?? 0
       },
       trades: trades.map((trade) => ({ trade })),
       signals: signals2.map((signal) => ({ signal })),
       evaluations: evaluations.map((evaluation) => ({ evaluation })),
       evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+      lineageScopes: lineageScopes ?? [],
       strategyConfigs: strategyConfigs ?? []
     });
     buildRuntimeDebugReportAttachment = async (params) => {
@@ -24899,7 +24945,8 @@ var init_replayRuntimeEvidence = __esm({
         return {
           source: "file",
           path: runtimeEvidencePath,
-          payload: artifact.runtime ?? artifact
+          payload: artifact.runtime ?? artifact,
+          deployment: artifact.deployment ?? null
         };
       }
       const runtimeEvidence2 = await collectRuntimeDebugEvidence({
@@ -24911,6 +24958,7 @@ var init_replayRuntimeEvidence = __esm({
       return {
         source: "local-redis",
         path: null,
+        deployment: null,
         payload: buildRuntimeEvidenceReportPayload({
           userName: userName3,
           startTime,
@@ -24919,7 +24967,8 @@ var init_replayRuntimeEvidence = __esm({
           evaluations: runtimeEvidence2.evaluations,
           trades: runtimeEvidence2.trades,
           strategyConfigs: runtimeEvidence2.strategyConfigs,
-          evaluationStatsBuckets: runtimeEvidence2.evaluationStatsBuckets
+          evaluationStatsBuckets: runtimeEvidence2.evaluationStatsBuckets,
+          lineageScopes: runtimeEvidence2.lineageScopes
         })
       };
     };
@@ -24959,6 +25008,7 @@ var init_replayRuntimeEvidence = __esm({
           type: runtime.source,
           path: runtime.path
         },
+        deployment: runtime.deployment,
         replay: {
           key: replay.key,
           availableKeys: replay.availableKeys,
@@ -25283,7 +25333,7 @@ async function buildRuntimeLineage({
     maxLossValue: resolveRuntimeMaxLossValue(config2)
   };
 }
-var import_node_child_process6, import_node_crypto11, import_promises23, import_node_path17, import_types8, import_strategies10, import_strategyReleaseEvidence2, RUNTIME_CONTEXT_ENV_KEYS, RUNTIME_CONTEXT_DATA_MODEL, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, gitLineageCache, gateFingerprintCache, binanceBreadthFingerprintCache, snapshotFingerprintCache, resolveGitLineage, readOptionalFile, resolveBinanceBreadthFingerprint, resolveSnapshotFingerprint, resolveRuntimeGateFingerprint, runtimeLineageKey, runtimeLineagesMatch;
+var import_node_child_process6, import_node_crypto11, import_promises23, import_node_path17, import_types8, import_strategies10, import_strategyReleaseEvidence2, RUNTIME_CONTEXT_ENV_KEYS, RUNTIME_CONTEXT_DATA_MODEL, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, gitLineageCache, gateFingerprintCache, binanceBreadthFingerprintCache, snapshotFingerprintCache, resolveGitLineage, readOptionalFile, resolveBinanceBreadthFingerprint, resolveSnapshotFingerprint, resolveRuntimeGateFingerprint, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
 var init_runtimeLineage = __esm({
   "src/lib/runtimeLineage.ts"() {
     "use strict";
@@ -25469,7 +25519,12 @@ var init_runtimeLineage = __esm({
       gateFingerprintCache.set(cacheKey, result);
       return result;
     };
-    runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.version].join(":") : [
+    runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? [
+      "v2",
+      lineage.version,
+      lineage.strategyPackageVersion ?? "strategy:unknown",
+      lineage.runtimePackageVersion ?? "runtime:unknown"
+    ].join(":") : [
       lineage.schemaVersion,
       lineage.compositionId ?? "unbound-composition",
       lineage.gitSha ?? "unknown",
@@ -25479,26 +25534,163 @@ var init_runtimeLineage = __esm({
       lineage.contextFingerprint
     ].join(":");
     runtimeLineagesMatch = (left, right) => left != null && right != null && runtimeLineageKey(left) === runtimeLineageKey(right);
+    runtimeLineagesComparable = (left, right) => runtimeLineagesMatch(left, right) && typeof left?.maxLossValue === "number" && Number.isFinite(left.maxLossValue) && typeof right?.maxLossValue === "number" && Number.isFinite(right.maxLossValue) && left.maxLossValue === right.maxLossValue;
   }
 });
 
-// src/scripts/runtimeEvidence.ts
-var runtimeEvidence_exports = {};
-__export(runtimeEvidence_exports, {
-  main: () => main34,
-  runtimeEvidence: () => runtimeEvidence
-});
-var import_promises24, import_node_path18, import_args26, import_chalk39, flags25, projectRoot9, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main34;
-var init_runtimeEvidence = __esm({
-  "src/scripts/runtimeEvidence.ts"() {
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies3, isRecord, isNonEmptyString, INTERVALS, UNIVERSES, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
+var init_runtimeEvidenceDeployment = __esm({
+  "src/lib/runtimeEvidenceDeployment.ts"() {
     "use strict";
-    import_promises24 = __toESM(require("fs/promises"));
+    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
+    isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+    INTERVALS = /* @__PURE__ */ new Set([
+      "1",
+      "3",
+      "5",
+      "15",
+      "30",
+      "60",
+      "120",
+      "240",
+      "360",
+      "720",
+      "D",
+      "W",
+      "M"
+    ]);
+    UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+    parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+      if (!isRecord(value) || value.schemaVersion !== 1 || !isNonEmptyString(value.id) || !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) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || 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) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig)) {
+          throw new Error(
+            "Runtime evidence deployment strategy snapshot is invalid"
+          );
+        }
+        if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+          throw new Error(
+            `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+          );
+        }
+        if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+          throw new Error(
+            `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+          );
+        }
+        return candidate;
+      });
+      const identities = /* @__PURE__ */ new Set();
+      for (const strategy of strategies) {
+        if (identities.has(strategy.strategyName)) {
+          throw new Error(
+            `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+          );
+        }
+        identities.add(strategy.strategyName);
+      }
+      return {
+        ...value,
+        strategies
+      };
+    };
+    activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+    runtimeDeploymentFromEvidence = (deployment) => ({
+      id: deployment.id,
+      label: deployment.label,
+      connectorName: deployment.connectorName,
+      provider: deployment.provider,
+      accountId: deployment.accountId,
+      enabled: deployment.enabled,
+      strategies: deployment.strategies.map(
+        ({ strategyName, version, enabled, controlState }) => ({
+          strategyName,
+          version,
+          enabled,
+          controlState
+        })
+      ),
+      ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+      ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+    });
+    resolveRuntimeEvidenceDeploymentSnapshot = async ({
+      userName: userName3,
+      projectRoot: projectRoot15,
+      deploymentId
+    }) => {
+      const [deployment, strategies] = await Promise.all([
+        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot15, deploymentId }),
+        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot15, deploymentId })
+      ]);
+      if (!deployment) {
+        throw new Error(`Runtime deployment not found: ${deploymentId}`);
+      }
+      return {
+        schemaVersion: 1,
+        id: deployment.id,
+        label: deployment.label,
+        connectorName: deployment.connectorName,
+        provider: deployment.provider,
+        accountId: deployment.accountId,
+        enabled: deployment.enabled,
+        strategies: strategies.map(
+          ({
+            strategyName,
+            version,
+            enabled,
+            controlState,
+            interval: interval4,
+            universe,
+            accountId,
+            strategyPackage,
+            strategyPackageVersion,
+            runtimePackageVersion,
+            sourceStrategyConfig
+          }) => ({
+            strategyName,
+            version,
+            enabled,
+            controlState,
+            interval: interval4,
+            universe,
+            ...accountId ? { accountId } : {},
+            strategyPackage,
+            strategyPackageVersion,
+            runtimePackageVersion,
+            strategyConfig: sourceStrategyConfig
+          })
+        ),
+        ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+        ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+      };
+    };
+  }
+});
+
+// src/scripts/runtimeEvidence.ts
+var runtimeEvidence_exports = {};
+__export(runtimeEvidence_exports, {
+  main: () => main34,
+  runtimeEvidence: () => runtimeEvidence
+});
+var import_promises24, import_node_path18, import_args26, import_chalk39, flags25, projectRoot9, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main34;
+var init_runtimeEvidence = __esm({
+  "src/scripts/runtimeEvidence.ts"() {
+    "use strict";
+    import_promises24 = __toESM(require("fs/promises"));
     import_node_path18 = __toESM(require("path"));
     import_args26 = __toESM(require("args"));
     import_chalk39 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
     init_runtimeEvidenceArtifacts();
     init_runtimeLineage();
+    init_runtimeEvidenceDeployment();
     import_args26.default.option(["u", "user"], "Use user config", "root");
     import_args26.default.option(
       ["S", "startTime"],
@@ -25577,12 +25769,34 @@ var init_runtimeEvidence = __esm({
     parseStrategyFilter2 = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
     runtimeEvidence = async () => {
       const { startTime, endTime, source } = resolveWindow2();
-      const strategies = parseStrategyFilter2(flags25.strategy);
+      const deploymentId = String(flags25.deployment);
+      const deployment = await resolveRuntimeEvidenceDeploymentSnapshot({
+        userName: String(flags25.user),
+        projectRoot: projectRoot9,
+        deploymentId
+      });
+      const activeStrategies = activeRuntimeEvidenceStrategies(deployment).map(
+        ({ strategyName }) => strategyName
+      );
+      const requestedStrategies = parseStrategyFilter2(flags25.strategy);
+      const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
+      const declaredStrategies = new Set(
+        deployment.strategies.map(({ strategyName }) => strategyName)
+      );
+      const unknownStrategies = strategies.filter(
+        (strategyName) => !declaredStrategies.has(strategyName)
+      );
+      if (unknownStrategies.length) {
+        throw new Error(
+          `Strategies are not declared in ${deploymentId}: ${unknownStrategies.join(", ")}`
+        );
+      }
       const evidence = await collectRuntimeDebugEvidence({
         userName: flags25.user,
         startTime,
         endTime,
-        strategies: strategies.length ? strategies : void 0
+        strategies,
+        deploymentId
       });
       const runtime = buildRuntimeEvidenceReportPayload({
         userName: flags25.user,
@@ -25592,7 +25806,8 @@ var init_runtimeEvidence = __esm({
         evaluations: evidence.evaluations,
         trades: evidence.trades,
         strategyConfigs: evidence.strategyConfigs,
-        evaluationStatsBuckets: evidence.evaluationStatsBuckets
+        evaluationStatsBuckets: evidence.evaluationStatsBuckets,
+        lineageScopes: evidence.lineageScopes
       });
       const artifact = {
         reportType: "runtime-evidence",
@@ -25606,6 +25821,7 @@ var init_runtimeEvidence = __esm({
           source
         },
         strategies,
+        deployment,
         runtime
       };
       const outPath = import_node_path18.default.resolve(projectRoot9, String(flags25.out));
@@ -25615,7 +25831,7 @@ var init_runtimeEvidence = __esm({
       const publishDir = String(flags25.publishDir ?? "").trim();
       const published = publishDir ? await publishRuntimeEvidenceBundle({
         publishRoot: import_node_path18.default.resolve(projectRoot9, publishDir),
-        deploymentId: String(flags25.deployment),
+        deploymentId,
         userName: String(flags25.user),
         startTime,
         endTime,
@@ -25626,8 +25842,9 @@ var init_runtimeEvidence = __esm({
           ...evidence.evaluations.map(
             (evaluation) => evaluation.runtimeLineage
           ),
-          ...evidence.trades.map((trade) => trade.runtimeLineage)
-        ].filter((lineage) => lineage != null).map(runtimeLineageKey)
+          ...evidence.trades.map((trade) => trade.runtimeLineage),
+          ...evidence.lineageScopes.map((scope) => scope.lineage)
+        ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
       }) : null;
       console.log(import_chalk39.default.green(`Wrote ${outPath}`));
       if (published) {
@@ -25886,10 +26103,11 @@ var init_runtimeEvidenceSync2 = __esm({
 });
 
 // src/lib/runtimeScorecard.ts
-var asRecord6, asArray3, finiteNumber5, finiteString2, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildRuntimeLineageSummary, belongsToStrategy, filterArtifactByStrategy, countBy2, buildDistributions, buildDistributionDelta, sum2, statsCount, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getCalibrationSummary, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
+var asRecord6, asArray3, finiteNumber5, finiteString2, round, unwrapRows, runtimePayload, runtimeWindow, extractRuntimeRows, buildRuntimeLineageSummary, belongsToRuntimeLineage, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, buildDistributions, buildDistributionDelta, sum2, statsCount, tradeTimestamp, dedupeTrades, maxDrawdown, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getCalibrationSummary, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
 var init_runtimeScorecard = __esm({
   "src/lib/runtimeScorecard.ts"() {
     "use strict";
+    init_runtimeLineage();
     asRecord6 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     asArray3 = (value) => Array.isArray(value) ? value : [];
     finiteNumber5 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -25910,15 +26128,32 @@ var init_runtimeScorecard = __esm({
         evaluations: unwrapRows(runtime.evaluations, "evaluation"),
         signals: unwrapRows(runtime.signals, "signal"),
         trades: unwrapRows(runtime.trades, "trade"),
+        lineageScopes: unwrapRows(runtime.lineageScopes, "lineageScope"),
         statsBuckets: asArray3(runtime.evaluationStatsBuckets).map(asRecord6).filter((item) => item != null)
       };
     };
     buildRuntimeLineageSummary = (rows) => {
-      const lineageRows = [...rows.evaluations, ...rows.signals, ...rows.trades];
+      const lineageRows = [
+        ...rows.evaluations,
+        ...rows.signals,
+        ...rows.trades,
+        ...rows.lineageScopes.map((scope) => ({
+          runtimeLineage: scope.lineage
+        }))
+      ];
       const lineages = lineageRows.map((row) => asRecord6(row.runtimeLineage)).filter((lineage) => lineage != null);
       const identities = /* @__PURE__ */ new Map();
       for (const lineage of lineages) {
-        const identity2 = {
+        const identity2 = lineage.schemaVersion === 2 ? {
+          schemaVersion: 2,
+          version: finiteNumber5(lineage.version),
+          strategyPackageVersion: finiteString2(
+            lineage.strategyPackageVersion
+          ),
+          runtimePackageVersion: finiteString2(lineage.runtimePackageVersion),
+          maxLossValue: finiteNumber5(lineage.maxLossValue)
+        } : {
+          schemaVersion: 1,
           compositionId: finiteString2(lineage.compositionId),
           gitSha: finiteString2(lineage.gitSha),
           gitDirty: typeof lineage.gitDirty === "boolean" ? lineage.gitDirty : null,
@@ -25930,12 +26165,23 @@ var init_runtimeScorecard = __esm({
         identities.set(JSON.stringify(identity2), identity2);
       }
       const identity = identities.size === 1 ? [...identities.values()][0] : null;
-      const complete = lineageRows.length > 0 && lineages.length === lineageRows.length && identity != null && identity.compositionId != null && identity.gitSha != null && identity.gitDirty === false && identity.gateFingerprint != null && identity.configFingerprint != null && identity.contextFingerprint != null && identity.maxLossValue != null;
+      const schemaVersion = finiteNumber5(identity?.schemaVersion);
+      const identityComplete = lineages.length > 0 && identity != null && (schemaVersion === 2 && finiteNumber5(identity.version) != null && finiteString2(identity.strategyPackageVersion) != null && finiteString2(identity.runtimePackageVersion) != null || schemaVersion === 1 && identity.compositionId != null && identity.gitSha != null && identity.gitDirty === false && identity.gateFingerprint != null && identity.configFingerprint != null && identity.contextFingerprint != null) && identity.maxLossValue != null;
+      const coverageComplete = lineageRows.length > 0 && lineages.length === lineageRows.length;
+      const complete = identityComplete && coverageComplete;
+      const lineageKey = identityComplete ? runtimeLineageKey(identity) : null;
       return {
         complete,
+        identityComplete,
+        coverageComplete,
         conflicts: identities.size > 1,
         rows: lineageRows.length,
         rowsWithLineage: lineages.length,
+        schemaVersion,
+        lineageKey,
+        version: finiteNumber5(identity?.version),
+        strategyPackageVersion: finiteString2(identity?.strategyPackageVersion),
+        runtimePackageVersion: finiteString2(identity?.runtimePackageVersion),
         compositionId: finiteString2(identity?.compositionId),
         gitSha: finiteString2(identity?.gitSha),
         gitDirty: typeof identity?.gitDirty === "boolean" ? identity.gitDirty : null,
@@ -25945,6 +26191,20 @@ var init_runtimeScorecard = __esm({
         maxLossValue: finiteNumber5(identity?.maxLossValue)
       };
     };
+    belongsToRuntimeLineage = (row, summary) => {
+      if (!summary.identityComplete || !summary.lineageKey) return false;
+      const lineage = asRecord6(row.runtimeLineage);
+      if (!lineage) return false;
+      return runtimeLineageKey(lineage) === summary.lineageKey && finiteNumber5(lineage.maxLossValue) === summary.maxLossValue;
+    };
+    runtimeDeploymentBinding = (artifact) => {
+      const deployment = asRecord6(asRecord6(artifact)?.deployment);
+      return {
+        deploymentId: finiteString2(deployment?.id),
+        accountId: finiteString2(deployment?.accountId)
+      };
+    };
+    belongsToRuntimeDeployment = (row, binding) => binding.deploymentId == null && binding.accountId == null ? true : finiteString2(row.deploymentId) === binding.deploymentId && finiteString2(row.accountId) === binding.accountId;
     belongsToStrategy = (row, strategy) => strategy == null || finiteString2(row.strategy) === strategy;
     filterArtifactByStrategy = (artifact, strategy) => {
       if (!strategy) return artifact;
@@ -25972,6 +26232,9 @@ var init_runtimeScorecard = __esm({
               strategy
             )
           ),
+          lineageScopes: asArray3(runtime.lineageScopes).filter(
+            (item) => belongsToStrategy(asRecord6(item) ?? {}, strategy)
+          ),
           evaluationStatsBuckets: asArray3(runtime.evaluationStatsBuckets).filter(
             (item) => belongsToStrategy(asRecord6(item) ?? {}, strategy)
           )
@@ -26151,6 +26414,7 @@ var init_runtimeScorecard = __esm({
       const scopedHistoryArtifacts = historyRuntimeArtifacts.map(
         (artifact) => filterArtifactByStrategy(artifact, strategy)
       );
+      const deploymentBinding = runtimeDeploymentBinding(runtimeArtifact);
       const rows = extractRuntimeRows(scopedRuntimeArtifact);
       const runtimeLineage = buildRuntimeLineageSummary(rows);
       const window = runtimeWindow(runtimeArtifact);
@@ -26213,6 +26477,12 @@ var init_runtimeScorecard = __esm({
         ...scopedHistoryArtifacts,
         scopedRuntimeArtifact
       ]);
+      const comparableHistoryTrades = historyTrades.filter(
+        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && belongsToRuntimeLineage(trade, runtimeLineage)
+      );
+      const comparableCurrentClosedTrades = currentClosedTrades.filter(
+        (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && belongsToRuntimeLineage(trade, runtimeLineage)
+      );
       const currentDistributions = buildDistributions(rows);
       const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
         const candidateEndTime = finiteNumber5(candidateWindow.endTime);
@@ -26223,7 +26493,7 @@ var init_runtimeScorecard = __esm({
       const previousDistributions = previousArtifact ? buildDistributions(extractRuntimeRows(previousArtifact.artifact)) : null;
       const rolling = [7, 30, 90].map(
         (days) => buildRollingPerformance({
-          trades: [...historyTrades],
+          trades: [...comparableHistoryTrades],
           anchorTime: endTime,
           days
         })
@@ -26237,6 +26507,13 @@ var init_runtimeScorecard = __esm({
           message: lineageReason
         });
       }
+      if (!runtimeLineage.complete) {
+        reactions.push({
+          code: "RUNTIME_LINEAGE_INCOMPLETE",
+          severity: "blocking",
+          message: "Runtime rows do not share one complete composition lineage."
+        });
+      }
       if (parityRatio != null && parityRatio < thresholds.minimumParityRatio) {
         reactions.push({
           code: "PARITY_REGRESSION",
@@ -26274,6 +26551,7 @@ var init_runtimeScorecard = __esm({
         generatedAt,
         window: { startTime, endTime },
         strategy,
+        deployment: deploymentBinding,
         lineage: runtimeLineage,
         promotionStatus,
         thresholds,
@@ -26318,17 +26596,25 @@ var init_runtimeScorecard = __esm({
             )
           ).length,
           fills: rows.trades.length,
-          closedTrades: currentClosedTrades.length
+          closedTrades: currentClosedTrades.length,
+          comparableClosedTrades: comparableCurrentClosedTrades.length,
+          nonComparableClosedTrades: currentClosedTrades.length - comparableCurrentClosedTrades.length
         },
         realized: {
           pnl: sum2(
-            currentClosedTrades.map((trade) => finiteNumber5(trade.closedPnl))
+            comparableCurrentClosedTrades.map(
+              (trade) => finiteNumber5(trade.closedPnl)
+            )
           ),
           fees: sum2(
-            currentClosedTrades.map((trade) => finiteNumber5(trade.totalFee))
+            comparableCurrentClosedTrades.map(
+              (trade) => finiteNumber5(trade.totalFee)
+            )
           ),
           funding: sum2(
-            currentClosedTrades.map((trade) => finiteNumber5(trade.fundingFee))
+            comparableCurrentClosedTrades.map(
+              (trade) => finiteNumber5(trade.fundingFee)
+            )
           )
         },
         gateComparison: {
@@ -28094,13 +28380,13 @@ __export(runtimeControl_exports, {
   main: () => main37,
   runtimeControl: () => runtimeControl
 });
-var import_config9, import_runtimeControls, import_runtimeStrategies2, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot12, userName2, verify, inspect, updateControlState, runtimeControl, main37;
+var import_config9, import_runtimeControls, import_runtimeStrategies4, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot12, userName2, verify, inspect, updateControlState, runtimeControl, main37;
 var init_runtimeControl = __esm({
   "src/scripts/runtimeControl.ts"() {
     "use strict";
     import_config9 = require("dotenv/config");
     import_runtimeControls = require("@tradejs/infra/runtimeControls");
-    import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
     argv = process.argv.slice(2);
     RUNTIME_CONTROL_ACTIONS = [
       "inspect",
@@ -28121,7 +28407,7 @@ var init_runtimeControl = __esm({
     projectRoot12 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     userName2 = String(option("user") ?? process.env.USER_NAME ?? "root");
     verify = async () => {
-      const deployments = await (0, import_runtimeStrategies2.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 });
+      const deployments = await (0, import_runtimeStrategies4.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 });
       const requestedDeployment = option("deployment");
       const selected = requestedDeployment ? deployments.filter((deployment) => deployment.id === requestedDeployment) : deployments;
       if (requestedDeployment && !selected.length) {
@@ -28130,7 +28416,7 @@ var init_runtimeControl = __esm({
       const results2 = [];
       for (const deployment of selected) {
         try {
-          const strategies = await (0, import_runtimeStrategies2.loadResolvedRuntimeStrategies)({
+          const strategies = await (0, import_runtimeStrategies4.loadResolvedRuntimeStrategies)({
             userName: userName2,
             projectRoot: projectRoot12,
             deploymentId: deployment.id
@@ -28164,7 +28450,7 @@ var init_runtimeControl = __esm({
     inspect = async () => {
       const requestedDeployment = option("deployment");
       const requestedStrategy = option("strategy");
-      const deployments = (await (0, import_runtimeStrategies2.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 })).filter(
+      const deployments = (await (0, import_runtimeStrategies4.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 })).filter(
         (deployment) => !requestedDeployment || deployment.id === requestedDeployment
       ).map((deployment) => ({
         ...deployment,
@@ -28177,7 +28463,7 @@ var init_runtimeControl = __esm({
     updateControlState = async (nextState) => {
       const deploymentId = required2("deployment");
       const strategyName = required2("strategy");
-      const deployment = await (0, import_runtimeStrategies2.getRuntimeDeployment)({
+      const deployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
         userName: userName2,
         projectRoot: projectRoot12,
         deploymentId
@@ -28207,7 +28493,7 @@ var init_runtimeControl = __esm({
       } else {
         await (0, import_runtimeControls.resumeRuntimeStrategy)({ userName: userName2, deploymentId, strategyName });
       }
-      const updated = await (0, import_runtimeStrategies2.getRuntimeDeployment)({
+      const updated = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
         userName: userName2,
         projectRoot: projectRoot12,
         deploymentId
@@ -31155,11 +31441,11 @@ var init_hooks = __esm({
 });
 
 // src/lib/signals/runtimeStrategies.ts
-var import_runtimeStrategies3;
+var import_runtimeStrategies5;
 var init_runtimeStrategies = __esm({
   "src/lib/signals/runtimeStrategies.ts"() {
     "use strict";
-    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies5 = require("@tradejs/node/runtimeStrategies");
   }
 });
 
@@ -31234,9 +31520,28 @@ var init_evaluations = __esm({
       symbol,
       timestamp,
       runtimeConfigId,
-      runtimeVersion
-    }) => runtimeVersion ? [strategyName, `v${runtimeVersion}`, symbol, timestamp].join(":") : runtimeConfigId && runtimeConfigId !== "config" ? [strategyName, runtimeConfigId, symbol, timestamp].join(":") : [strategyName, symbol, timestamp].join(":");
+      runtimeVersion,
+      deploymentId,
+      accountId
+    }) => {
+      const runtimeScope = deploymentId ? [deploymentId, accountId ?? "default-account"] : [];
+      return runtimeVersion ? [
+        ...runtimeScope,
+        strategyName,
+        `v${runtimeVersion}`,
+        symbol,
+        timestamp
+      ].join(":") : runtimeConfigId && runtimeConfigId !== "config" ? [
+        ...runtimeScope,
+        strategyName,
+        runtimeConfigId,
+        symbol,
+        timestamp
+      ].join(":") : [...runtimeScope, strategyName, symbol, timestamp].join(":");
+    };
     buildLineageField = (scope) => [
+      scope.deploymentId ?? "default-deployment",
+      scope.accountId ?? "default-account",
       scope.strategy,
       scope.runtimeConfigId ?? "config",
       scope.runtimeVersion ? `v${scope.runtimeVersion}` : "legacy",
@@ -31278,6 +31583,8 @@ var init_evaluations = __esm({
         for (const evaluation of lineageEvaluations) {
           const lineageField = buildLineageField({
             strategy: evaluation.strategy,
+            deploymentId: evaluation.deploymentId,
+            accountId: evaluation.accountId,
             runtimeConfigId: evaluation.runtimeConfigId,
             runtimeVersion: evaluation.runtimeVersion,
             symbol: evaluation.symbol,
@@ -31288,6 +31595,8 @@ var init_evaluations = __esm({
           const scope = {
             strategy: evaluation.strategy,
             symbol: evaluation.symbol,
+            ...evaluation.deploymentId ? { deploymentId: evaluation.deploymentId } : {},
+            ...evaluation.accountId ? { accountId: evaluation.accountId } : {},
             runtimeConfigId: evaluation.runtimeConfigId,
             runtimeVersion: evaluation.runtimeVersion,
             lineage: evaluation.runtimeLineage,
@@ -31331,7 +31640,8 @@ var init_evaluations = __esm({
           const statsBucket = import_redis18.redisKeys.runtimeSignalEvaluationStatsBucket(
             evaluation.userName,
             dayKey,
-            evaluation.strategy
+            evaluation.strategy,
+            evaluation.deploymentId
           );
           const increments = statsIncrements.get(statsBucket) ?? {};
           for (const [field, increment] of Object.entries(
@@ -31954,7 +32264,9 @@ var init_tickerEvaluator = __esm({
               symbol,
               timestamp: lastCandle.timestamp,
               runtimeConfigId: runtimeIdentity,
-              runtimeVersion: version
+              runtimeVersion: version,
+              deploymentId,
+              accountId
             }),
             userName: userName3,
             strategy: strategyName,
@@ -31979,8 +32291,14 @@ var init_tickerEvaluator = __esm({
         signal.runtimeConfigId = runtimeIdentity;
         signal.runtimeVersion = version;
         signal.runtimeLineage = runtimeLineage;
-        if (version && !signal.signalId.endsWith(`:v${version}`)) {
-          signal.signalId = `${signal.signalId}:v${version}`;
+        signal.deploymentId = deploymentId;
+        signal.accountId = accountId;
+        const signalRuntimeIdentity = [
+          ...deploymentId ? [deploymentId, accountId ?? "default-account"] : [],
+          ...version ? [`v${version}`] : []
+        ].join(":");
+        if (signalRuntimeIdentity && !signal.signalId.endsWith(`:${signalRuntimeIdentity}`)) {
+          signal.signalId = `${signal.signalId}:${signalRuntimeIdentity}`;
         }
         await (0, import_strategies11.enrichSignalWithBinanceMarketContext)({ signal, env: "CRON" });
         if (signal.orderStatus === "skipped" && typeof signal.orderSkipReason === "string" && signal.orderSkipReason.trim()) {
@@ -31999,7 +32317,9 @@ var init_tickerEvaluator = __esm({
             symbol,
             timestamp: lastCandle.timestamp,
             runtimeConfigId: runtimeIdentity,
-            runtimeVersion: version
+            runtimeVersion: version,
+            deploymentId,
+            accountId
           }),
           userName: userName3,
           strategy: strategyName,
@@ -32083,7 +32403,7 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies12, import_constants16, import_time8, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies4, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
+var import_progress11, import_chalk45, import_connectors16, import_cli12, import_async5, import_strategies12, import_constants16, import_time8, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
@@ -32097,7 +32417,7 @@ var init_runner = __esm({
     import_time8 = require("@tradejs/core/time");
     import_logger10 = require("@tradejs/infra/logger");
     import_runtimeHeartbeats = require("@tradejs/infra/runtimeHeartbeats");
-    import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
     init_windows();
     init_runFormatting();
     init_hooks();
@@ -32173,7 +32493,7 @@ var init_runner = __esm({
         return connectorName;
       };
       const createSignalsSession2 = async (lifecycle, scope = {}) => {
-        const deployment = config2.deploymentId ? await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+        const deployment = config2.deploymentId ? await (0, import_runtimeStrategies6.getRuntimeDeployment)({
           userName: config2.userName,
           projectRoot: projectRoot15,
           deploymentId: config2.deploymentId
@@ -32398,7 +32718,7 @@ var init_runner = __esm({
           const primaryEthByTimestamp = new Map(
             primaryEthClosedData.map((candle) => [candle.timestamp, candle])
           );
-          const runtimeStrategies = await (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({
+          const runtimeStrategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
             userName: config2.userName,
             projectRoot: projectRoot15,
             deploymentId: deployment?.id ?? "",
@@ -32612,7 +32932,7 @@ var init_runner = __esm({
         }
       };
       const loadConfiguredSignalsScopes = async (deployment) => {
-        const configuredStrategies = await (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({
+        const configuredStrategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
           userName: config2.userName,
           projectRoot: projectRoot15,
           deploymentId: deployment.id
@@ -32635,7 +32955,7 @@ var init_runner = __esm({
         if (!config2.deploymentId) {
           throw new Error("Runtime deployment id is required");
         }
-        const configuredDeployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+        const configuredDeployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
           userName: config2.userName,
           projectRoot: projectRoot15,
           deploymentId: config2.deploymentId
@@ -32669,7 +32989,7 @@ var init_runner = __esm({
           throw new Error("Runtime deployment id is required");
         }
         const deploymentId = config2.deploymentId;
-        const initialDeployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+        const initialDeployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
           userName: config2.userName,
           projectRoot: projectRoot15,
           deploymentId
@@ -32694,7 +33014,7 @@ var init_runner = __esm({
             settleDelayMs: resolveNonNegativeInteger(config2.settleDelayMs, 5e3),
             signal: abortController.signal,
             runCycle: async () => {
-              const currentDeployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
+              const currentDeployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
                 userName: config2.userName,
                 projectRoot: projectRoot15,
                 deploymentId
@@ -32899,7 +33219,7 @@ var init_signalsDaemon = __esm({
 });
 
 // src/lib/replay/cliConfig.ts
-var import_args32, REPLAY_UNSUPPORTED_FLAGS, hasCliFlag2, assertNoUnsupportedReplayFlags, replayNormalizedArgv, replayFlags, replayInterval, replayUserName, replayProjectRoot, replayRuntimeEvidencePath, isReplayUpdateOnlyRun;
+var import_args32, REPLAY_UNSUPPORTED_FLAGS, hasCliFlag2, assertNoUnsupportedReplayFlags, replayNormalizedArgv, replayFlags, replayInterval, replayUserName, replayProjectRoot, replayRuntimeEvidencePath, replayDeploymentId, isReplayUpdateOnlyRun;
 var init_cliConfig2 = __esm({
   "src/lib/replay/cliConfig.ts"() {
     "use strict";
@@ -32952,6 +33272,11 @@ var init_cliConfig2 = __esm({
       "runtimeEvidence",
       "Immutable runtime evidence JSON used for offline runtime comparison"
     );
+    import_args32.default.option(
+      "deployment",
+      "Git-owned runtime deployment used when runtime evidence is omitted",
+      "production"
+    );
     import_args32.default.option(["u", "updateOnly"], "Only update tickers history", false);
     import_args32.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
     import_args32.default.option(
@@ -32978,10 +33303,203 @@ var init_cliConfig2 = __esm({
     replayUserName = String(replayFlags.user ?? "root");
     replayProjectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     replayRuntimeEvidencePath = typeof replayFlags.runtimeEvidence === "string" && replayFlags.runtimeEvidence.trim() ? replayFlags.runtimeEvidence.trim() : null;
+    replayDeploymentId = String(
+      replayFlags.deployment ?? "production"
+    ).trim();
     isReplayUpdateOnlyRun = Boolean(replayFlags.updateOnly);
   }
 });
 
+// src/lib/replay/runtimeEvidenceSource.ts
+var import_promises29, import_node_path24, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
+var init_runtimeEvidenceSource = __esm({
+  "src/lib/replay/runtimeEvidenceSource.ts"() {
+    "use strict";
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path24 = __toESM(require("path"));
+    init_runtimeLineage();
+    init_runtimeEvidenceDeployment();
+    asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+    unwrapRows2 = (value, field) => (Array.isArray(value) ? value : []).map((item) => {
+      const row = asRecord7(item);
+      return asRecord7(row?.[field]) ?? row;
+    }).filter((item) => item != null);
+    assertRuntimeRowsMatchDeployment = ({
+      label,
+      rows,
+      deployment
+    }) => {
+      const activeStrategies = new Set(
+        activeRuntimeEvidenceStrategies(deployment).map(
+          ({ strategyName }) => strategyName
+        )
+      );
+      for (const row of rows) {
+        if (row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !row.strategy || !activeStrategies.has(row.strategy)) {
+          throw new Error(
+            `Runtime evidence ${label} row is outside embedded deployment composition`
+          );
+        }
+      }
+    };
+    readRuntimeEvidenceArtifact = async ({
+      filePath,
+      projectRoot: projectRoot15
+    }) => {
+      const resolvedPath = import_node_path24.default.resolve(projectRoot15, filePath);
+      const root = asRecord7(
+        JSON.parse(await import_promises29.default.readFile(resolvedPath, "utf8"))
+      );
+      const runtime = asRecord7(root?.runtime) ?? root;
+      if (!root || !runtime) {
+        throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
+      }
+      const rootWindow = asRecord7(root.window);
+      const runtimeWindow2 = asRecord7(runtime.window);
+      return {
+        resolvedPath,
+        root,
+        runtime,
+        userName: String(root.userName ?? runtime.userName ?? "").trim(),
+        startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow2?.startTime),
+        endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow2?.endTime),
+        deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment)
+      };
+    };
+    loadReplayRuntimeEvidenceMetadata = async (params) => {
+      const artifact = await readRuntimeEvidenceArtifact(params);
+      return {
+        path: artifact.resolvedPath,
+        userName: artifact.userName,
+        startTime: artifact.startTime,
+        endTime: artifact.endTime,
+        deployment: artifact.deployment
+      };
+    };
+    buildRuntimeEvidenceLineageScopes = ({
+      signals: signals2,
+      evaluations
+    }) => {
+      const scopes = /* @__PURE__ */ new Map();
+      const add = ({
+        strategy,
+        symbol,
+        deploymentId,
+        accountId,
+        runtimeConfigId,
+        runtimeVersion,
+        timestamp,
+        lineage
+      }) => {
+        if (!lineage || !Number.isFinite(timestamp)) {
+          return;
+        }
+        const key = `${deploymentId ?? "default"}::${accountId ?? "default"}::${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
+        const existing = scopes.get(key);
+        scopes.set(key, {
+          strategy,
+          symbol,
+          ...deploymentId ? { deploymentId } : {},
+          ...accountId ? { accountId } : {},
+          ...runtimeConfigId ? { runtimeConfigId } : {},
+          ...runtimeVersion ? { runtimeVersion } : {},
+          lineage,
+          firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
+          lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
+        });
+      };
+      for (const signal of signals2) {
+        add({
+          strategy: signal.strategy,
+          symbol: signal.symbol,
+          deploymentId: signal.deploymentId,
+          accountId: signal.accountId,
+          runtimeConfigId: signal.runtimeConfigId,
+          runtimeVersion: signal.runtimeVersion,
+          timestamp: signal.timestamp,
+          lineage: signal.runtimeLineage
+        });
+      }
+      for (const evaluation of evaluations) {
+        add({
+          strategy: evaluation.strategy,
+          symbol: evaluation.symbol,
+          deploymentId: evaluation.deploymentId,
+          accountId: evaluation.accountId,
+          runtimeConfigId: evaluation.runtimeConfigId,
+          runtimeVersion: evaluation.runtimeVersion,
+          timestamp: evaluation.timestamp,
+          lineage: evaluation.runtimeLineage
+        });
+      }
+      return [...scopes.values()].sort(
+        (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.firstTimestamp - right.firstTimestamp
+      );
+    };
+    loadReplayRuntimeEvidenceSource = async ({
+      filePath,
+      projectRoot: projectRoot15,
+      expectedUserName,
+      expectedWindow
+    }) => {
+      const { resolvedPath, runtime, userName: userName3, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot: projectRoot15 });
+      if (!userName3 || userName3 !== expectedUserName) {
+        throw new Error(
+          `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName3 || "missing"}`
+        );
+      }
+      const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
+      if (startTime !== expectedWindow.start || !endTimeMatches) {
+        throw new Error(
+          `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
+        );
+      }
+      const trades = unwrapRows2(runtime.trades, "trade");
+      const signals2 = unwrapRows2(runtime.signals, "signal");
+      const evaluations = unwrapRows2(
+        runtime.evaluations,
+        "evaluation"
+      );
+      const storedLineageScopes = unwrapRows2(
+        runtime.lineageScopes,
+        "lineageScope"
+      );
+      assertRuntimeRowsMatchDeployment({
+        label: "trade",
+        rows: trades,
+        deployment
+      });
+      assertRuntimeRowsMatchDeployment({
+        label: "signal",
+        rows: signals2,
+        deployment
+      });
+      assertRuntimeRowsMatchDeployment({
+        label: "evaluation",
+        rows: evaluations,
+        deployment
+      });
+      assertRuntimeRowsMatchDeployment({
+        label: "lineage scope",
+        rows: storedLineageScopes,
+        deployment
+      });
+      return {
+        path: resolvedPath,
+        userName: userName3,
+        startTime,
+        endTime,
+        trades,
+        signals: signals2,
+        evaluations,
+        lineageScopes: storedLineageScopes.length ? storedLineageScopes : buildRuntimeEvidenceLineageScopes({ signals: signals2, evaluations }),
+        deployment
+      };
+    };
+  }
+});
+
 // src/lib/replay/portfolioReplayConnector.ts
 var import_constants17, import_math, import_trade2, UNKNOWN_STRATEGY, getStrategyName, getPositionPnlSnapshot, createPortfolioReplayConnector;
 var init_portfolioReplayConnector = __esm({
@@ -33393,7 +33911,7 @@ var init_portfolioReplayConnector = __esm({
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
-var import_chalk46, import_progress12, import_backtest4, import_strategies13, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies14, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
+var import_chalk46, import_progress12, import_backtest4, import_strategies13, import_time9, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies14, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildPreparedData, buildAfterSignalsContext, buildSymbolSharedReplayKey, runHistoricalSignalsReplay;
 var init_historicalSignalsReplay = __esm({
   "src/lib/replay/historicalSignalsReplay.ts"() {
     "use strict";
@@ -33407,6 +33925,7 @@ var init_historicalSignalsReplay = __esm({
     import_connectors17 = require("@tradejs/node/connectors");
     import_cli13 = require("@tradejs/node/cli");
     import_strategies14 = require("@tradejs/node/strategies");
+    import_runtimeStrategies8 = require("@tradejs/node/runtimeStrategies");
     init_cliConfig2();
     init_support();
     init_portfolioReplayConnector();
@@ -33415,7 +33934,15 @@ var init_historicalSignalsReplay = __esm({
     init_runtimeLineage();
     loadRuntimeStrategies = async (runtimeStrategies) => {
       const strategies = await Promise.all(
-        runtimeStrategies.map(async ({ strategyName, strategyConfig }) => {
+        runtimeStrategies.map(async (runtimeStrategy) => {
+          const {
+            strategyName,
+            version,
+            strategyPackage,
+            strategyPackageVersion,
+            runtimePackageVersion,
+            strategyConfig
+          } = runtimeStrategy;
           const strategyCreator = await (0, import_strategies14.getStrategyCreator)(
             strategyName,
             replayProjectRoot
@@ -33423,12 +33950,25 @@ var init_historicalSignalsReplay = __esm({
           if (!strategyCreator) {
             throw new Error(`Unknown strategy: ${strategyName}`);
           }
+          const installed = await (0, import_runtimeStrategies8.getRuntimeStrategyPackageMetadata)({
+            strategyName,
+            projectRoot: replayProjectRoot
+          });
+          if (installed.strategyPackage !== strategyPackage || installed.strategyPackageVersion !== strategyPackageVersion || installed.runtimePackageVersion !== runtimePackageVersion) {
+            throw new Error(
+              `Runtime evidence package mismatch for ${strategyName}: expected=${strategyPackage}@${strategyPackageVersion}/@tradejs/node@${runtimePackageVersion}, installed=${installed.strategyPackage ?? "missing"}@${installed.strategyPackageVersion ?? "missing"}/@tradejs/node@${installed.runtimePackageVersion ?? "missing"}`
+            );
+          }
           const strategyResults = await (0, import_redis19.getData)(
             import_redis19.redisKeys.strategyResults(replayUserName, strategyName),
             {}
           );
           return {
             strategyName,
+            version,
+            strategyPackage,
+            strategyPackageVersion,
+            runtimePackageVersion,
             strategyCreator,
             strategyConfig,
             strategyResults
@@ -33622,6 +34162,9 @@ var init_historicalSignalsReplay = __esm({
           loadedStrategies.map(
             async ({
               strategyName,
+              version,
+              strategyPackageVersion,
+              runtimePackageVersion,
               strategyCreator,
               strategyConfig,
               strategyResults
@@ -33629,8 +34172,11 @@ var init_historicalSignalsReplay = __esm({
               const runtimeLineage = await buildRuntimeLineage({
                 projectRoot: replayProjectRoot,
                 strategyName,
+                version,
+                strategyPackageVersion,
+                runtimePackageVersion,
                 config: {
-                  configId: "config",
+                  configId: `v${version}`,
                   strategyConfig,
                   symbolResultConfig: strategyResults?.[symbol]?.config ?? null
                 },
@@ -33643,6 +34189,8 @@ var init_historicalSignalsReplay = __esm({
               runtimeLineages.push({
                 strategy: strategyName,
                 symbol,
+                ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
+                ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
                 lineage: runtimeLineage
               });
               return {
@@ -33652,8 +34200,11 @@ var init_historicalSignalsReplay = __esm({
                 run: await strategyCreator({
                   userName: replayUserName,
                   connectorName,
-                  runtimeConfigId: "config",
+                  runtimeConfigId: `v${version}`,
                   runtimeLineage,
+                  universe: preparedRun.universe,
+                  accountId: preparedRun.accountId,
+                  deploymentId: preparedRun.deploymentId,
                   config: buildReplayStrategyConfig({
                     strategyConfig,
                     interval: interval4
@@ -35006,125 +35557,6 @@ var init_runtimeParityDetails = __esm({
   }
 });
 
-// src/lib/replay/runtimeEvidenceSource.ts
-var import_promises29, import_node_path24, asRecord7, asFiniteNumber, unwrapRows2, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
-var init_runtimeEvidenceSource = __esm({
-  "src/lib/replay/runtimeEvidenceSource.ts"() {
-    "use strict";
-    import_promises29 = __toESM(require("fs/promises"));
-    import_node_path24 = __toESM(require("path"));
-    init_runtimeLineage();
-    asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-    asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-    unwrapRows2 = (value, field) => (Array.isArray(value) ? value : []).map((item) => {
-      const row = asRecord7(item);
-      return asRecord7(row?.[field]) ?? row;
-    }).filter((item) => item != null);
-    buildRuntimeEvidenceLineageScopes = ({
-      signals: signals2,
-      evaluations
-    }) => {
-      const scopes = /* @__PURE__ */ new Map();
-      const add = ({
-        strategy,
-        symbol,
-        runtimeConfigId,
-        runtimeVersion,
-        timestamp,
-        lineage
-      }) => {
-        if (!lineage || !Number.isFinite(timestamp)) {
-          return;
-        }
-        const key = `${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
-        const existing = scopes.get(key);
-        scopes.set(key, {
-          strategy,
-          symbol,
-          ...runtimeConfigId ? { runtimeConfigId } : {},
-          ...runtimeVersion ? { runtimeVersion } : {},
-          lineage,
-          firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
-          lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
-        });
-      };
-      for (const signal of signals2) {
-        add({
-          strategy: signal.strategy,
-          symbol: signal.symbol,
-          runtimeConfigId: signal.runtimeConfigId,
-          runtimeVersion: signal.runtimeVersion,
-          timestamp: signal.timestamp,
-          lineage: signal.runtimeLineage
-        });
-      }
-      for (const evaluation of evaluations) {
-        add({
-          strategy: evaluation.strategy,
-          symbol: evaluation.symbol,
-          runtimeConfigId: evaluation.runtimeConfigId,
-          runtimeVersion: evaluation.runtimeVersion,
-          timestamp: evaluation.timestamp,
-          lineage: evaluation.runtimeLineage
-        });
-      }
-      return [...scopes.values()].sort(
-        (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.firstTimestamp - right.firstTimestamp
-      );
-    };
-    loadReplayRuntimeEvidenceSource = async ({
-      filePath,
-      projectRoot: projectRoot15,
-      expectedUserName,
-      expectedWindow
-    }) => {
-      const resolvedPath = import_node_path24.default.resolve(projectRoot15, filePath);
-      const root = asRecord7(
-        JSON.parse(await import_promises29.default.readFile(resolvedPath, "utf8"))
-      );
-      const runtime = asRecord7(root?.runtime) ?? root;
-      if (!root || !runtime) {
-        throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
-      }
-      const rootWindow = asRecord7(root.window);
-      const runtimeWindow2 = asRecord7(runtime.window);
-      const startTime = asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow2?.startTime);
-      const endTime = asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow2?.endTime);
-      const userName3 = String(root.userName ?? runtime.userName ?? "").trim();
-      if (!userName3 || userName3 !== expectedUserName) {
-        throw new Error(
-          `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName3 || "missing"}`
-        );
-      }
-      const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
-      if (startTime !== expectedWindow.start || !endTimeMatches) {
-        throw new Error(
-          `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
-        );
-      }
-      const trades = unwrapRows2(runtime.trades, "trade");
-      const signals2 = unwrapRows2(runtime.signals, "signal");
-      const evaluations = unwrapRows2(
-        runtime.evaluations,
-        "evaluation"
-      );
-      return {
-        path: resolvedPath,
-        userName: userName3,
-        startTime,
-        endTime,
-        trades,
-        signals: signals2,
-        evaluations,
-        lineageScopes: buildRuntimeEvidenceLineageScopes({
-          signals: signals2,
-          evaluations
-        })
-      };
-    };
-  }
-});
-
 // src/lib/replay/runtimeComparison.ts
 var import_chalk48, import_time11, getReplayEntryTimestampCompareOffsetMs, buildReplaySignalEvaluations, lineageScopeKey, buildExpectedLineageByScope, hasExpectedLineage, filterReplayComparisonByLineage, formatDrilldownSummary, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, summarizeBacktestPnlByStrategy, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, buildPriceDeltaPct3, loadExchangeEntriesForComparison, compareExchangeEntriesToBacktest, findExchangeRuntimeOutcome, splitExchangeMatchesByRuntimeOrderStatus, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
 var init_runtimeComparison = __esm({
@@ -35160,27 +35592,40 @@ var init_runtimeComparison = __esm({
       reason: signal.orderSkipReason || signal.orderStatus || "SIGNAL",
       signalId: signal.signalId,
       direction: signal.direction,
+      accountId: signal.accountId,
+      deploymentId: signal.deploymentId,
       runtimeLineage: signal.runtimeLineage,
       orderStatus: signal.orderStatus,
       orderSkipReason: signal.orderSkipReason,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
       ...signal.ml ? { ml: signal.ml } : {}
     }));
-    lineageScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
+    lineageScopeKey = ({
+      strategy,
+      symbol,
+      deploymentId,
+      accountId
+    }) => `${deploymentId ?? "default-deployment"}::${accountId ?? "default-account"}::${strategy}::${symbol}`;
     buildExpectedLineageByScope = (replayLineages) => new Map(
-      replayLineages.map((record) => [
-        lineageScopeKey(record.strategy, record.symbol),
-        record.lineage
-      ])
+      replayLineages.map((record) => [lineageScopeKey(record), record.lineage])
     );
     hasExpectedLineage = ({
       strategy,
       symbol,
+      deploymentId,
+      accountId,
       lineage,
       expectedByScope
-    }) => runtimeLineagesMatch(
+    }) => runtimeLineagesComparable(
       lineage,
-      expectedByScope.get(lineageScopeKey(strategy, symbol))
+      expectedByScope.get(
+        lineageScopeKey({
+          strategy,
+          symbol,
+          deploymentId,
+          accountId
+        })
+      )
     );
     filterReplayComparisonByLineage = ({
       replayLineages,
@@ -35195,6 +35640,8 @@ var init_runtimeComparison = __esm({
         (signal) => hasExpectedLineage({
           strategy: signal.strategy,
           symbol: signal.symbol,
+          deploymentId: signal.deploymentId,
+          accountId: signal.accountId,
           lineage: signal.runtimeLineage,
           expectedByScope
         })
@@ -35203,6 +35650,8 @@ var init_runtimeComparison = __esm({
         (evaluation) => hasExpectedLineage({
           strategy: evaluation.strategy,
           symbol: evaluation.symbol,
+          deploymentId: evaluation.deploymentId,
+          accountId: evaluation.accountId,
           lineage: evaluation.runtimeLineage,
           expectedByScope
         })
@@ -35211,13 +35660,15 @@ var init_runtimeComparison = __esm({
         (scope) => hasExpectedLineage({
           strategy: scope.strategy,
           symbol: scope.symbol,
+          deploymentId: scope.deploymentId,
+          accountId: scope.accountId,
           lineage: scope.lineage,
           expectedByScope
         })
       );
       const deploymentWindows = /* @__PURE__ */ new Map();
       for (const scope of comparableRuntimeLineageScopes) {
-        const key = lineageScopeKey(scope.strategy, scope.symbol);
+        const key = lineageScopeKey(scope);
         const existing = deploymentWindows.get(key);
         deploymentWindows.set(key, {
           firstTimestamp: existing == null ? scope.firstTimestamp : Math.min(existing.firstTimestamp, scope.firstTimestamp),
@@ -35241,13 +35692,13 @@ var init_runtimeComparison = __esm({
           return hasExpectedLineage({
             strategy: trade.strategy,
             symbol: trade.symbol,
+            deploymentId: trade.deploymentId,
+            accountId: trade.accountId,
             lineage,
             expectedByScope
           });
         }
-        const window = deploymentWindows.get(
-          lineageScopeKey(trade.strategy, trade.symbol)
-        );
+        const window = deploymentWindows.get(lineageScopeKey(trade));
         const signalTimestamp = trade.signalTimestamp ?? trade.entryTimestamp;
         return window != null && signalTimestamp >= window.firstTimestamp && signalTimestamp <= window.lastTimestamp;
       });
@@ -35255,17 +35706,24 @@ var init_runtimeComparison = __esm({
         ...comparableRuntimeSignals,
         ...comparableRuntimeEvaluations
       ]) {
-        const key = lineageScopeKey(artifact.strategy, artifact.symbol);
+        const key = lineageScopeKey(artifact);
         const existing = deploymentWindows.get(key);
         deploymentWindows.set(key, {
           firstTimestamp: existing == null ? artifact.timestamp : Math.min(existing.firstTimestamp, artifact.timestamp),
           lastTimestamp: existing == null ? artifact.timestamp : Math.max(existing.lastTimestamp, artifact.timestamp)
         });
       }
+      const replayScopeByStrategySymbol = new Map(
+        replayLineages.map((record) => [
+          `${record.strategy}::${record.symbol}`,
+          lineageScopeKey(record)
+        ])
+      );
       const comparableBacktestEntries = backtestEntries.filter((entry) => {
-        const window = deploymentWindows.get(
-          lineageScopeKey(entry.strategy, entry.symbol)
+        const replayScope = replayScopeByStrategySymbol.get(
+          `${entry.strategy}::${entry.symbol}`
         );
+        const window = replayScope ? deploymentWindows.get(replayScope) : null;
         const signalTimestamp = entry.signalTimestamp ?? entry.timestamp;
         return window != null && signalTimestamp >= window.firstTimestamp && signalTimestamp <= window.lastTimestamp;
       });
@@ -35287,10 +35745,12 @@ var init_runtimeComparison = __esm({
           excludedBacktestEntries: backtestEntries.length - comparableBacktestEntries.length,
           reason: comparableScopeKeys.size > 0 ? null : "no_runtime_artifacts_with_matching_lineage",
           replay: [...expectedByScope.entries()].map(([scope, lineage]) => {
-            const separator = scope.indexOf("::");
+            const [deploymentId, accountId, strategy, symbol] = scope.split("::");
             return {
-              strategy: scope.slice(0, separator),
-              symbol: scope.slice(separator + 2),
+              deploymentId,
+              accountId,
+              strategy,
+              symbol,
               lineage
             };
           }).sort(
@@ -36602,6 +37062,8 @@ var init_replayRunner = __esm({
     init_marketContextPrepare();
     init_runState();
     init_cliConfig2();
+    init_runtimeEvidenceSource();
+    init_runtimeEvidenceDeployment();
     init_support();
     init_historicalSignalsReplay();
     init_chartSnapshot();
@@ -36725,10 +37187,69 @@ var init_replayRunner = __esm({
     };
     replayBacktest = async () => {
       resetRunState();
+      const evidenceMetadata = replayRuntimeEvidencePath ? await loadReplayRuntimeEvidenceMetadata({
+        filePath: replayRuntimeEvidencePath,
+        projectRoot: replayProjectRoot
+      }) : null;
+      if (evidenceMetadata && evidenceMetadata.userName !== replayUserName) {
+        throw new Error(
+          `Runtime evidence user mismatch: expected=${replayUserName}, actual=${evidenceMetadata.userName || "missing"}`
+        );
+      }
+      const replayComposition = evidenceMetadata ? {
+        deployment: runtimeDeploymentFromEvidence(evidenceMetadata.deployment),
+        strategies: activeRuntimeEvidenceStrategies(
+          evidenceMetadata.deployment
+        ).map(
+          ({
+            strategyName,
+            version,
+            strategyPackage,
+            strategyPackageVersion,
+            runtimePackageVersion,
+            strategyConfig
+          }) => ({
+            strategyName,
+            version,
+            strategyPackage,
+            strategyPackageVersion,
+            runtimePackageVersion,
+            strategyConfig
+          })
+        )
+      } : await loadDeploymentReplayStrategies({
+        userName: replayUserName,
+        projectRoot: replayProjectRoot,
+        deploymentId: replayDeploymentId
+      });
+      const { deployment, strategies: replayStrategies } = replayComposition;
+      if (!replayStrategies.length) {
+        throw new Error(`No enabled strategies in deployment ${deployment.id}`);
+      }
+      const strategyIntervals = new Set(
+        replayStrategies.map(
+          ({ strategyConfig }) => String(strategyConfig.INTERVAL)
+        )
+      );
+      if (strategyIntervals.size !== 1 || !strategyIntervals.has(replayInterval)) {
+        throw new Error(
+          `Replay interval does not match deployment ${deployment.id}: replay=${replayInterval}, strategies=${[...strategyIntervals].join(",")}`
+        );
+      }
+      const strategyUniverses = new Set(
+        replayStrategies.map(
+          ({ strategyConfig }) => String(strategyConfig.UNIVERSE)
+        )
+      );
+      if (strategyUniverses.size !== 1) {
+        throw new Error(
+          `Replay requires one deployment universe: ${[...strategyUniverses].join(",")}`
+        );
+      }
       const preparedRun = await prepareRunEnvironment({
-        connector: replayFlags.connector,
+        connector: deployment.connectorName,
         userName: replayUserName,
-        tickers: replayFlags.tickers,
+        tickers: replayFlags.tickers ?? deployment.tickers,
         exclude: replayFlags.exclude,
         tickersLimit: replayFlags.tickersLimit,
         showTickersList: replayFlags.showTickersList,
@@ -36738,6 +37259,11 @@ var init_replayRunner = __esm({
         cacheOnly: replayFlags.cacheOnly,
         interval: replayInterval,
         projectRoot: replayProjectRoot,
+        universe: [...strategyUniverses][0],
+        accountId: deployment.accountId,
+        deploymentId: deployment.id,
+        assetClasses: deployment.assetClasses,
+        deployment,
         closedIntervalMs: (0, import_data5.intervalToMs)(replayInterval)
       });
       if (!preparedRun || isReplayUpdateOnlyRun) {
@@ -36751,10 +37277,6 @@ var init_replayRunner = __esm({
           end: preparedRun.window.end
         }
       });
-      const replayStrategies = await loadReplayStrategies(replayUserName);
-      if (!replayStrategies.length) {
-        return;
-      }
       await prepareReplayBinanceMarketContext({
         ...preparedRun,
         aiEnabled: replayStrategies.some(
@@ -36812,7 +37334,7 @@ __export(signalsSummary_exports, {
   main: () => main44,
   signalsSummary: () => signalsSummary
 });
-var import_config13, import_args33, import_logger12, import_connectors18, import_runtimeStrategies6, flags30, projectRoot14, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml6, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main44;
+var import_config13, import_args33, import_logger12, import_connectors18, import_runtimeStrategies9, flags30, projectRoot14, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml6, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main44;
 var init_signalsSummary = __esm({
   "src/scripts/signalsSummary.ts"() {
     "use strict";
@@ -36826,7 +37348,7 @@ var init_signalsSummary = __esm({
     init_runtimeSignalsLoader();
     init_runtimeSignalsStorage();
     init_runtimeDebugEvidence();
-    import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies9 = require("@tradejs/node/runtimeStrategies");
     import_args33.default.option(["u", "user"], "Use user config", "root");
     import_args33.default.option(
       "connector",
@@ -37364,7 +37886,7 @@ none`
         loadRuntimeSignals(flags30.user, { startTime, endTime }),
         loadRuntimeSignalEvaluationStatsBuckets(flags30.user),
         loadRuntimeTrades(flags30.user),
-        (0, import_runtimeStrategies6.listRuntimeDeployments)({ userName: flags30.user, projectRoot: projectRoot14 })
+        (0, import_runtimeStrategies9.listRuntimeDeployments)({ userName: flags30.user, projectRoot: projectRoot14 })
       ]);
       const {
         trades: syncedTrades,