@tradejs/cli 2.0.18 → 2.0.20

package/dist/lib/runtimeDebugEvidence.js

@@ -34,17 +34,7 @@ var import_redis3 = require("@tradejs/infra/redis");
 // src/lib/runtimeRedis.ts
 var import_redis = require("@tradejs/infra/redis");
 var import_time = require("@tradejs/core/time");
-var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
-var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
-var resolveStrategyConfigIdentityByKey = (userName, key) => {
-  const parts = key.split(":");
-  if (parts.length !== 5) return null;
-  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
-  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
-    return null;
-  }
-  return { strategyName, configId };
-};
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
 var isRuntimeTradeRecord = (value) => {
   if (!value || typeof value !== "object") {
     return false;
@@ -52,42 +42,6 @@ var isRuntimeTradeRecord = (value) => {
   const record = value;
   return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
 };
-var resolveStrategyNameByConfigKey = (userName, key) => {
-  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
-};
-var getRuntimeStrategyConfigKeys = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
-  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
-};
-var loadRuntimeStrategyConfigs = async (userName, {
-  onInvalidConfig
-} = {}) => {
-  const configKeys = await getRuntimeStrategyConfigKeys(userName);
-  const strategyConfigs = await Promise.all(
-    configKeys.map(async (key) => {
-      const strategyName = resolveStrategyNameByConfigKey(userName, key);
-      const identity = resolveStrategyConfigIdentityByKey(userName, key);
-      if (!strategyName || !identity) {
-        return null;
-      }
-      const strategyConfig = await (0, import_redis.getData)(
-        key,
-        null
-      );
-      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
-        onInvalidConfig?.(key);
-        return null;
-      }
-      return {
-        key,
-        strategyName,
-        configId: identity.configId,
-        strategyConfig
-      };
-    })
-  );
-  return strategyConfigs.filter(Boolean);
-};
 var loadRuntimeTrades = async (userName, {
   startTime,
   endTime
@@ -356,7 +310,7 @@ var collectRuntimeDebugEvidence = async ({
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
-    loadRuntimeStrategyConfigs(userName)
+    (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName)
   ]);
   const tradesByOrderId = new Map(
     entryTrades.map((trade) => [trade.orderId, trade])

package/dist/lib/runtimeLineage.js

@@ -38,11 +38,56 @@ __export(runtimeLineage_exports, {
 });
 module.exports = __toCommonJS(runtimeLineage_exports);
 var import_node_child_process = require("child_process");
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_types = require("@tradejs/types");
+var import_strategies = require("@tradejs/node/strategies");
+
+// src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
-var import_types = require("@tradejs/types");
-var import_strategies = require("@tradejs/node/strategies");
+var gateFingerprintRelativePaths = (strategyName) => [
+  `packages/strategies/src/${strategyName}/adapters/ai.ts`,
+  `packages/strategies/src/${strategyName}/guardrails.ts`,
+  `packages/strategies/src/${strategyName}/pockets.ts`,
+  `packages/strategies/src/${strategyName}/config.ts`,
+  "packages/strategies/src/shared/localAiGate.ts",
+  "packages/node/src/ai.ts",
+  "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
+];
+var resolveStrategyGateFingerprint = async ({
+  projectRoot,
+  strategyName,
+  gitSha
+}) => {
+  const candidates = await Promise.all(
+    gateFingerprintRelativePaths(strategyName).map(async (relativePath) => {
+      const content = await import_promises.default.readFile(import_node_path.default.join(projectRoot, relativePath)).catch(() => null);
+      return content == null ? null : { relativePath, content };
+    })
+  );
+  const sourceEntries = candidates.filter(
+    (entry) => entry != null
+  );
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  return {
+    gateFingerprint: hash.digest("hex").slice(0, 16),
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+  };
+};
+
+// src/lib/runtimeLineage.ts
 var RUNTIME_CONTEXT_ENV_KEYS = [
   "AI_MODE",
   "MIN_AI_QUALITY",
@@ -92,6 +137,17 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
+var normalizeRuntimeLogicConfig = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeRuntimeLogicConfig);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([key]) => key !== "MAX_LOSS_VALUE").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeRuntimeLogicConfig(entry)])
+    );
+  }
+  return value;
+};
 var resolveRuntimeMaxLossValue = (config) => {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return null;
@@ -105,7 +161,7 @@ var resolveRuntimeMaxLossValue = (config) => {
   );
   return Number.isFinite(maxLossValue) ? maxLossValue : null;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
 var gitLineageCache = /* @__PURE__ */ new Map();
 var gateFingerprintCache = /* @__PURE__ */ new Map();
 var binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
@@ -156,7 +212,7 @@ var resolveGitLineage = (projectRoot) => {
 };
 var readOptionalFile = async (filePath) => {
   try {
-    return await import_promises.default.readFile(filePath);
+    return await import_promises2.default.readFile(filePath);
   } catch {
     return null;
   }
@@ -166,7 +222,7 @@ var resolveBinanceBreadthFingerprint = async (projectRoot) => {
     return binanceBreadthFingerprintCache.get(projectRoot) ?? null;
   }
   const content = await readOptionalFile(
-    import_node_path.default.join(
+    import_node_path2.default.join(
       projectRoot,
       "packages/node/src/config/binanceBreadthUniverses.json"
     )
@@ -188,7 +244,7 @@ var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
   if (snapshotFingerprintCache.has(cacheKey)) {
     return snapshotFingerprintCache.get(cacheKey) ?? null;
   }
-  const content = await readOptionalFile(import_node_path.default.join(projectRoot, relativePath));
+  const content = await readOptionalFile(import_node_path2.default.join(projectRoot, relativePath));
   let result = null;
   if (content) {
     try {
@@ -201,55 +257,26 @@ var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
   snapshotFingerprintCache.set(cacheKey, result);
   return result;
 };
-var resolveGateFingerprint = async ({
+var resolveRuntimeGateFingerprint = async ({
   projectRoot,
   strategyName,
   gitSha
 }) => {
   const cacheKey = `${projectRoot}:${strategyName}:${gitSha ?? "unknown"}`;
   const cached = gateFingerprintCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const relativeCandidates = [
-    `packages/strategies/src/${strategyName}/adapters/ai.ts`,
-    `packages/strategies/src/${strategyName}/guardrails.ts`,
-    `packages/strategies/src/${strategyName}/pockets.ts`,
-    `packages/strategies/src/${strategyName}/config.ts`,
-    "packages/node/src/ai.ts",
-    "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
-  ];
-  const optionalEntries = await Promise.all(
-    relativeCandidates.map(async (relativePath) => {
-      const content = await readOptionalFile(
-        import_node_path.default.join(projectRoot, relativePath)
-      );
-      return content == null ? null : { relativePath, content };
-    })
-  );
-  const sourceEntries = [];
-  for (const entry of optionalEntries) {
-    if (entry != null) {
-      sourceEntries.push(entry);
-    }
-  }
-  const hash = (0, import_node_crypto.createHash)("sha256");
-  hash.update(strategyName);
-  if (sourceEntries.length) {
-    for (const entry of sourceEntries) {
-      hash.update(entry.relativePath);
-      hash.update(entry.content);
-    }
-  } else {
-    hash.update(gitSha ?? "unknown-git-sha");
-  }
-  const fingerprint = hash.digest("hex").slice(0, 16);
-  gateFingerprintCache.set(cacheKey, fingerprint);
-  return fingerprint;
+  if (cached) return cached;
+  const result = await resolveStrategyGateFingerprint({
+    projectRoot,
+    strategyName,
+    gitSha
+  });
+  gateFingerprintCache.set(cacheKey, result);
+  return result;
 };
 var buildRuntimeLineage = async ({
   projectRoot,
   strategyName,
+  compositionId,
   config,
   runContext,
   env = process.env
@@ -275,19 +302,25 @@ var buildRuntimeLineage = async ({
   };
   return {
     schemaVersion: 1,
+    compositionId: compositionId?.trim() || null,
     ...git,
-    gateFingerprint: await resolveGateFingerprint({
+    gateFingerprint: (await resolveRuntimeGateFingerprint({
       projectRoot,
       strategyName,
       gitSha: git.gitSha
-    }),
-    configFingerprint: fingerprintRuntimeValue(config),
+    })).gateFingerprint,
+    // Position risk is tracked separately so changing trade size does not
+    // masquerade as a change to the core + gate decision logic.
+    configFingerprint: fingerprintRuntimeValue(
+      normalizeRuntimeLogicConfig(config)
+    ),
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
 };
 var runtimeLineageKey = (lineage) => [
   lineage.schemaVersion,
+  lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",
   lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
   lineage.gateFingerprint,

package/dist/lib/runtimeRedis.js

@@ -20,32 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/runtimeRedis.ts
 var runtimeRedis_exports = {};
 __export(runtimeRedis_exports, {
-  getRuntimeStrategyConfigKeys: () => getRuntimeStrategyConfigKeys,
+  getRuntimeStrategyConfigKeys: () => import_runtimeStrategyConfigs.getRuntimeStrategyConfigKeys,
   isRuntimeStrategyEnabled: () => isRuntimeStrategyEnabled,
   isRuntimeTradeRecord: () => isRuntimeTradeRecord,
   loadRuntimeActiveTradeOrderIds: () => loadRuntimeActiveTradeOrderIds,
   loadRuntimeClosedTrades: () => loadRuntimeClosedTrades,
-  loadRuntimeStrategyConfigs: () => loadRuntimeStrategyConfigs,
-  loadRuntimeStrategyNames: () => loadRuntimeStrategyNames,
+  loadRuntimeStrategyConfigs: () => import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs,
+  loadRuntimeStrategyNames: () => import_runtimeStrategyConfigs.loadRuntimeStrategyNames,
   loadRuntimeTrades: () => loadRuntimeTrades,
   loadStrategyResultSymbols: () => loadStrategyResultSymbols,
-  resolveStrategyConfigIdentityByKey: () => resolveStrategyConfigIdentityByKey,
-  resolveStrategyNameByConfigKey: () => resolveStrategyNameByConfigKey
+  resolveStrategyConfigIdentityByKey: () => import_runtimeStrategyConfigs.resolveStrategyConfigIdentityByKey,
+  resolveStrategyNameByConfigKey: () => import_runtimeStrategyConfigs.resolveStrategyNameByConfigKey
 });
 module.exports = __toCommonJS(runtimeRedis_exports);
 var import_redis = require("@tradejs/infra/redis");
 var import_time = require("@tradejs/core/time");
-var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
-var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
-var resolveStrategyConfigIdentityByKey = (userName, key) => {
-  const parts = key.split(":");
-  if (parts.length !== 5) return null;
-  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
-  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
-    return null;
-  }
-  return { strategyName, configId };
-};
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
 var isRuntimeStrategyEnabled = (strategyConfig) => {
   const enabled = strategyConfig.ENABLE;
   return enabled !== false;
@@ -57,47 +47,6 @@ var isRuntimeTradeRecord = (value) => {
   const record = value;
   return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
 };
-var resolveStrategyNameByConfigKey = (userName, key) => {
-  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
-};
-var getRuntimeStrategyConfigKeys = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
-  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
-};
-var loadRuntimeStrategyNames = async (userName) => [
-  ...new Set(
-    (await getRuntimeStrategyConfigKeys(userName)).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value))
-  )
-].sort((left, right) => left.localeCompare(right));
-var loadRuntimeStrategyConfigs = async (userName, {
-  onInvalidConfig
-} = {}) => {
-  const configKeys = await getRuntimeStrategyConfigKeys(userName);
-  const strategyConfigs = await Promise.all(
-    configKeys.map(async (key) => {
-      const strategyName = resolveStrategyNameByConfigKey(userName, key);
-      const identity = resolveStrategyConfigIdentityByKey(userName, key);
-      if (!strategyName || !identity) {
-        return null;
-      }
-      const strategyConfig = await (0, import_redis.getData)(
-        key,
-        null
-      );
-      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
-        onInvalidConfig?.(key);
-        return null;
-      }
-      return {
-        key,
-        strategyName,
-        configId: identity.configId,
-        strategyConfig
-      };
-    })
-  );
-  return strategyConfigs.filter(Boolean);
-};
 var loadRuntimeTrades = async (userName, {
   startTime,
   endTime

package/dist/lib/runtimeScorecard.js

@@ -47,6 +47,71 @@ var extractRuntimeRows = (artifact) => {
     statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord).filter((item) => item != null)
   };
 };
+var buildRuntimeLineageSummary = (rows) => {
+  const lineageRows = [...rows.evaluations, ...rows.signals, ...rows.trades];
+  const lineages = lineageRows.map((row) => asRecord(row.runtimeLineage)).filter((lineage) => lineage != null);
+  const identities = /* @__PURE__ */ new Map();
+  for (const lineage of lineages) {
+    const identity2 = {
+      compositionId: finiteString(lineage.compositionId),
+      gitSha: finiteString(lineage.gitSha),
+      gitDirty: typeof lineage.gitDirty === "boolean" ? lineage.gitDirty : null,
+      gateFingerprint: finiteString(lineage.gateFingerprint),
+      configFingerprint: finiteString(lineage.configFingerprint),
+      contextFingerprint: finiteString(lineage.contextFingerprint),
+      maxLossValue: finiteNumber(lineage.maxLossValue)
+    };
+    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;
+  return {
+    complete,
+    conflicts: identities.size > 1,
+    rows: lineageRows.length,
+    rowsWithLineage: lineages.length,
+    compositionId: finiteString(identity?.compositionId),
+    gitSha: finiteString(identity?.gitSha),
+    gitDirty: typeof identity?.gitDirty === "boolean" ? identity.gitDirty : null,
+    gateFingerprint: finiteString(identity?.gateFingerprint),
+    configFingerprint: finiteString(identity?.configFingerprint),
+    contextFingerprint: finiteString(identity?.contextFingerprint),
+    maxLossValue: finiteNumber(identity?.maxLossValue)
+  };
+};
+var belongsToStrategy = (row, strategy) => strategy == null || finiteString(row.strategy) === strategy;
+var filterArtifactByStrategy = (artifact, strategy) => {
+  if (!strategy) return artifact;
+  const root = asRecord(artifact) ?? {};
+  const runtime = runtimePayload(artifact);
+  return {
+    ...root,
+    runtime: {
+      ...runtime,
+      evaluations: asArray(runtime.evaluations).filter(
+        (item) => belongsToStrategy(
+          asRecord(asRecord(item)?.evaluation) ?? asRecord(item) ?? {},
+          strategy
+        )
+      ),
+      signals: asArray(runtime.signals).filter(
+        (item) => belongsToStrategy(
+          asRecord(asRecord(item)?.signal) ?? asRecord(item) ?? {},
+          strategy
+        )
+      ),
+      trades: asArray(runtime.trades).filter(
+        (item) => belongsToStrategy(
+          asRecord(asRecord(item)?.trade) ?? asRecord(item) ?? {},
+          strategy
+        )
+      ),
+      evaluationStatsBuckets: asArray(runtime.evaluationStatsBuckets).filter(
+        (item) => belongsToStrategy(asRecord(item) ?? {}, strategy)
+      )
+    }
+  };
+};
 var countBy = (items, getter) => {
   const counts = {};
   for (const item of items) {
@@ -165,14 +230,43 @@ var getReplayComparison = (artifact) => {
   const root = asRecord(artifact) ?? {};
   return asRecord(asRecord(root.replay)?.runtimeComparison) ?? null;
 };
+var replayCountsForStrategy = (replayComparison, strategy) => {
+  if (strategy) {
+    const byStrategy = asRecord(replayComparison?.byStrategy);
+    const strategyCounts = asRecord(byStrategy?.[strategy]);
+    if (strategyCounts) {
+      return {
+        matched: finiteNumber(strategyCounts.matched) ?? 0,
+        backtestOnly: finiteNumber(strategyCounts.backtestOnly) ?? 0,
+        runtimeOnly: finiteNumber(strategyCounts.runtimeOnly) ?? 0
+      };
+    }
+  }
+  const counts = asRecord(replayComparison?.counts);
+  return {
+    matched: finiteNumber(counts?.matched) ?? 0,
+    backtestOnly: finiteNumber(counts?.backtestOnly) ?? 0,
+    runtimeOnly: finiteNumber(counts?.runtimeOnly) ?? 0
+  };
+};
 var getCalibrationSummary = (artifact) => {
   const root = asRecord(artifact) ?? {};
   return asRecord(asRecord(root.summary)?.all) ?? null;
 };
+var getProspectiveSummary = (artifact) => {
+  const root = asRecord(artifact);
+  if (!root || root.reportType !== "strategy-prospective-evidence") return null;
+  return {
+    rawCoreExpectancy: finiteNumber(root.rawCoreExpectancy),
+    aiGateExpectancy: finiteNumber(root.aiGateExpectancy),
+    regimeCoverage: finiteNumber(root.regimeCoverage)
+  };
+};
 var buildRuntimeScorecard = ({
   runtimeArtifact,
   replayEvidenceArtifact,
   calibrationArtifact,
+  prospectiveEvidenceArtifact,
   historyRuntimeArtifacts = [],
   thresholds = {
     minimumParityRatio: 0.95,
@@ -180,9 +274,19 @@ var buildRuntimeScorecard = ({
     minimumClosedTrades: 20,
     minimumExpectancy: 0
   },
-  generatedAt = Date.now()
+  generatedAt = Date.now(),
+  strategy = null,
+  llmComparatorPolicy = "ai_approved_only"
 }) => {
-  const rows = extractRuntimeRows(runtimeArtifact);
+  const scopedRuntimeArtifact = filterArtifactByStrategy(
+    runtimeArtifact,
+    strategy
+  );
+  const scopedHistoryArtifacts = historyRuntimeArtifacts.map(
+    (artifact) => filterArtifactByStrategy(artifact, strategy)
+  );
+  const rows = extractRuntimeRows(scopedRuntimeArtifact);
+  const runtimeLineage = buildRuntimeLineageSummary(rows);
   const window = runtimeWindow(runtimeArtifact);
   const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
   const endTime = finiteNumber(window.endTime) ?? generatedAt;
@@ -197,6 +301,20 @@ var buildRuntimeScorecard = ({
   })).filter(
     ({ decision }) => decision === "approved" || decision === "rejected"
   );
+  const llmEligibleEvaluations = llmComparatorPolicy === "disabled" ? [] : llmComparatorPolicy === "ai_approved_only" ? signalEvaluations.filter(
+    (evaluation) => finiteString(asRecord(evaluation.aiAnalysis)?.gateDecision) === "approved"
+  ) : signalEvaluations;
+  const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
+    const analysis = asRecord(evaluation.aiAnalysis);
+    const gateDecision = finiteString(analysis?.gateDecision);
+    const llmDecision = finiteString(analysis?.llmDecision);
+    if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
+      return null;
+    }
+    return { gateDecision, llmDecision };
+  }).filter(
+    (comparison) => Boolean(comparison)
+  );
   const allocatorDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.allocatorDecision)).filter((item) => item != null);
   const riskDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.riskDecision)).filter((item) => item != null);
   const orderAttempts = rows.signals.filter(
@@ -207,27 +325,30 @@ var buildRuntimeScorecard = ({
     return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
   });
   const replayComparison = getReplayComparison(replayEvidenceArtifact);
-  const replayCounts = asRecord(replayComparison?.counts);
-  const matched = finiteNumber(replayCounts?.matched) ?? 0;
-  const backtestOnly = finiteNumber(replayCounts?.backtestOnly) ?? 0;
-  const runtimeOnly = finiteNumber(replayCounts?.runtimeOnly) ?? 0;
+  const replayCounts = replayCountsForStrategy(replayComparison, strategy);
+  const matched = replayCounts.matched;
+  const backtestOnly = replayCounts.backtestOnly;
+  const runtimeOnly = replayCounts.runtimeOnly;
   const comparisonTotal = matched + backtestOnly + runtimeOnly;
   const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
   const lineage = asRecord(replayComparison?.lineage);
   const lineageReason = finiteString(lineage?.reason);
-  const calibration = getCalibrationSummary(calibrationArtifact);
+  const calibrationRoot = asRecord(calibrationArtifact) ?? {};
+  const calibrationSummary = asRecord(calibrationRoot.summary);
+  const calibration = strategy ? asRecord(asRecord(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
   const actualSlippageBps = finiteNumber(
     asRecord(calibration?.signalToFillAdverseBps)?.avg
   );
   const residualVsModelBps = finiteNumber(
     asRecord(calibration?.residualVsCurrentModelBps)?.avg
   );
+  const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
   const historyTrades = dedupeTrades([
-    ...historyRuntimeArtifacts,
-    runtimeArtifact
+    ...scopedHistoryArtifacts,
+    scopedRuntimeArtifact
   ]);
   const currentDistributions = buildDistributions(rows);
-  const previousArtifact = historyRuntimeArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
+  const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
     const candidateEndTime = finiteNumber(candidateWindow.endTime);
     return candidateEndTime != null && candidateEndTime <= startTime;
   }).sort(
@@ -286,6 +407,8 @@ var buildRuntimeScorecard = ({
     schemaVersion: 1,
     generatedAt,
     window: { startTime, endTime },
+    strategy,
+    lineage: runtimeLineage,
     promotionStatus,
     thresholds,
     funnel: {
@@ -342,6 +465,24 @@ var buildRuntimeScorecard = ({
         currentClosedTrades.map((trade) => finiteNumber(trade.fundingFee))
       )
     },
+    gateComparison: {
+      policy: llmComparatorPolicy,
+      eligible: llmEligibleEvaluations.length,
+      compared: gateComparisons.length,
+      coverage: llmEligibleEvaluations.length ? round(gateComparisons.length / llmEligibleEvaluations.length) : null,
+      agreements: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === comparison.llmDecision
+      ).length,
+      disagreements: gateComparisons.filter(
+        (comparison) => comparison.gateDecision !== comparison.llmDecision
+      ).length,
+      gateApprovedLlmRejected: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === "approved" && comparison.llmDecision === "rejected"
+      ).length,
+      gateRejectedLlmApproved: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === "rejected" && comparison.llmDecision === "approved"
+      ).length
+    },
     parity: {
       available: comparisonTotal > 0,
       matched,
@@ -355,6 +496,7 @@ var buildRuntimeScorecard = ({
       actualSignalToFillSlippageBps: actualSlippageBps,
       residualVsCurrentModelBps: residualVsModelBps
     },
+    prospective,
     rolling,
     distributions: currentDistributions,
     distributionChanges: {
@@ -407,6 +549,7 @@ Window: ${new Date(scorecard.window.startTime).toISOString()} \u2014 ${new Date(
 - Evaluations: ${scorecard.funnel.evaluations}
 - Core candidates: ${scorecard.funnel.coreCandidates}
 - Gate approvals/rejects: ${scorecard.funnel.gate.approved}/${scorecard.funnel.gate.rejected}
+- AI / LLM disagreement: ${scorecard.gateComparison.disagreements}/${scorecard.gateComparison.compared}
 - Allocator approvals/rejects: ${scorecard.funnel.allocator.available ? `${scorecard.funnel.allocator.approved}/${scorecard.funnel.allocator.rejected}` : "unavailable"}
 - Risk approvals/rejects: ${scorecard.funnel.risk.available ? `${scorecard.funnel.risk.approved}/${scorecard.funnel.risk.rejected}` : "unavailable"}
 - Order attempts/failures: ${scorecard.funnel.orderAttempts}/${scorecard.funnel.orderFailures}

package/dist/lib/runtimeStrategyBacktest.js

@@ -40,57 +40,11 @@ var import_chalk = __toESM(require("chalk"));
 // src/lib/runtimeRedis.ts
 var import_redis = require("@tradejs/infra/redis");
 var import_time = require("@tradejs/core/time");
-var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
-var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
-var resolveStrategyConfigIdentityByKey = (userName, key) => {
-  const parts = key.split(":");
-  if (parts.length !== 5) return null;
-  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
-  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
-    return null;
-  }
-  return { strategyName, configId };
-};
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
 var isRuntimeStrategyEnabled = (strategyConfig) => {
   const enabled = strategyConfig.ENABLE;
   return enabled !== false;
 };
-var resolveStrategyNameByConfigKey = (userName, key) => {
-  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
-};
-var getRuntimeStrategyConfigKeys = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
-  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
-};
-var loadRuntimeStrategyConfigs = async (userName, {
-  onInvalidConfig
-} = {}) => {
-  const configKeys = await getRuntimeStrategyConfigKeys(userName);
-  const strategyConfigs = await Promise.all(
-    configKeys.map(async (key) => {
-      const strategyName = resolveStrategyNameByConfigKey(userName, key);
-      const identity = resolveStrategyConfigIdentityByKey(userName, key);
-      if (!strategyName || !identity) {
-        return null;
-      }
-      const strategyConfig = await (0, import_redis.getData)(
-        key,
-        null
-      );
-      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
-        onInvalidConfig?.(key);
-        return null;
-      }
-      return {
-        key,
-        strategyName,
-        configId: identity.configId,
-        strategyConfig
-      };
-    })
-  );
-  return strategyConfigs.filter(Boolean);
-};
 
 // src/lib/runtimeStrategyBacktest.ts
 var BACKTEST_CLI_RUNTIME_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -105,7 +59,7 @@ var toStrategyConfigGrid = (strategyConfig) => Object.fromEntries(
   Object.entries(strategyConfig).filter(([key]) => !BACKTEST_CLI_RUNTIME_CONFIG_KEYS.has(key)).map(([key, value]) => [key, [value]])
 );
 var loadRuntimeStrategyBacktestConfigs = async (userName) => {
-  const configs = await loadRuntimeStrategyConfigs(userName, {
+  const configs = await (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName, {
     onInvalidConfig: (key) => {
       console.log(import_chalk.default.yellow(`Skip invalid runtime strategy config: ${key}`));
     }