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

package/dist/lib/runtimeScorecard.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/runtimeScorecard.ts
@@ -36,21 +26,7 @@ __export(runtimeScorecard_exports, {
 module.exports = __toCommonJS(runtimeScorecard_exports);
 
 // src/lib/runtimeLineage.ts
-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");
-var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
-
-// src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
-var import_node_module = require("module");
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-
-// src/lib/runtimeLineage.ts
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -62,26 +38,174 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
-var runtimeLineageKey = (lineage) => lineage.schemaVersion === 3 ? [
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var runtimeLineageKey = (lineage) => [
   "v3",
   lineage.deploymentCompositionId,
   lineage.strategyRevision,
   lineage.strategyPackageVersion,
-  `deps:${fingerprintRuntimeValue(
-    lineage.strategyDependencyVersions
-  ).slice(0, 16)}`,
+  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
   lineage.runtimePackageVersion
-].join(":") : [
-  lineage.schemaVersion,
-  lineage.compositionId ?? "unbound-composition",
-  lineage.gitSha ?? "unknown",
-  lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
-  lineage.gateFingerprint,
-  lineage.configFingerprint,
-  lineage.contextFingerprint
 ].join(":");
 
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
+  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
+);
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
+var samePackageVersions = (left, right) => {
+  if (!left || !right) return false;
+  const leftEntries = Object.entries(left).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const rightEntries = Object.entries(right).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
+};
+var runtimeLineageMatchesStrategySnapshot = ({
+  lineage,
+  deployment,
+  strategy
+}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
+  lineage.strategyDependencyVersions,
+  strategy.strategyDependencyVersions
+);
+var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
+    throw new Error(
+      "Runtime evidence deployment snapshot is missing or invalid"
+    );
+  }
+  const strategies = value.strategies.map((candidate) => {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
+      throw new Error(
+        "Runtime evidence deployment strategy snapshot is invalid"
+      );
+    }
+    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+      throw new Error(
+        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+      );
+    }
+    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+      throw new Error(
+        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+      );
+    }
+    return candidate;
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (identities.has(strategy.strategyName)) {
+      throw new Error(
+        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+      );
+    }
+    identities.add(strategy.strategyName);
+  }
+  return {
+    ...value,
+    strategies
+  };
+};
+var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
+  const record = isRecord(candidate) ? candidate : null;
+  const nested = record && isRecord(record[field]) ? record[field] : null;
+  return nested ?? record;
+}).filter((record) => record != null);
+var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
+  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
+    throw new Error("Invalid runtime evidence artifact");
+  }
+  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+    artifact.deployment
+  );
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length === 0) {
+    throw new Error("Runtime evidence deployment has no enabled strategies");
+  }
+  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
+  if (!runtime) {
+    throw new Error("Runtime evidence payload is missing");
+  }
+  if ("strategyConfigs" in runtime) {
+    throw new Error(
+      "Runtime evidence payload contains removed strategyConfigs data"
+    );
+  }
+  const rowFields = [
+    "trades",
+    "signals",
+    "evaluations",
+    "lineageScopes"
+  ];
+  for (const field of rowFields) {
+    if (!Array.isArray(runtime[field])) {
+      throw new Error(`Runtime evidence payload ${field} must be an array`);
+    }
+  }
+  const snapshots = new Map(
+    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
+  );
+  const assertRows = (label, rows, lineageField) => {
+    for (const row of rows) {
+      const strategyName = String(row.strategy ?? "").trim();
+      const strategy = snapshots.get(strategyName);
+      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
+        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
+        deployment,
+        strategy
+      })) {
+        throw new Error(
+          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
+        );
+      }
+    }
+  };
+  assertRows(
+    "trade",
+    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "signal",
+    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "evaluation",
+    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "lineage scope",
+    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
+    "lineage"
+  );
+  return deployment;
+};
+
 // src/lib/runtimeScorecard.ts
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var asArray = (value) => Array.isArray(value) ? value : [];
@@ -120,75 +244,6 @@ var extractRuntimeRows = (artifact) => {
     statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord).filter((item) => item != null)
   };
 };
-var buildRuntimeLineageSummary = (rows) => {
-  const lineageRows = [
-    ...rows.evaluations,
-    ...rows.signals,
-    ...rows.trades,
-    ...rows.lineageScopes.map((scope) => ({
-      runtimeLineage: scope.lineage
-    }))
-  ];
-  const lineages = lineageRows.map((row) => asRecord(row.runtimeLineage)).filter((lineage) => lineage != null);
-  const identities = /* @__PURE__ */ new Map();
-  for (const lineage of lineages) {
-    const identity2 = lineage.schemaVersion === 3 ? {
-      schemaVersion: 3,
-      strategyRevision: finiteString(lineage.strategyRevision),
-      deploymentCompositionId: finiteString(
-        lineage.deploymentCompositionId
-      ),
-      strategyPackageVersion: finiteString(
-        lineage.strategyPackageVersion
-      ),
-      strategyDependencyVersions: packageVersionMap(
-        lineage.strategyDependencyVersions
-      ),
-      runtimePackageVersion: finiteString(lineage.runtimePackageVersion),
-      maxLossValue: finiteNumber(lineage.maxLossValue)
-    } : {
-      schemaVersion: 1,
-      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 schemaVersion = finiteNumber(identity?.schemaVersion);
-  const identityComplete = lineages.length > 0 && identity != null && (schemaVersion === 3 && finiteString(identity.strategyRevision) != null && finiteString(identity.deploymentCompositionId) != null && finiteString(identity.strategyPackageVersion) != null && packageVersionMap(identity.strategyDependencyVersions) != null && finiteString(identity.runtimePackageVersion) != null || schemaVersion === 1 && identity.compositionId != null && identity.gitSha != null && identity.gitDirty === false && identity.gateFingerprint != null && identity.configFingerprint != null && identity.contextFingerprint != null) && identity.maxLossValue != null;
-  const coverageComplete = lineageRows.length > 0 && lineages.length === lineageRows.length;
-  const complete = identityComplete && coverageComplete;
-  const lineageKey = identityComplete ? runtimeLineageKey(identity) : null;
-  return {
-    complete,
-    identityComplete,
-    coverageComplete,
-    conflicts: identities.size > 1,
-    rows: lineageRows.length,
-    rowsWithLineage: lineages.length,
-    schemaVersion,
-    lineageKey,
-    strategyRevision: finiteString(identity?.strategyRevision),
-    deploymentCompositionId: finiteString(identity?.deploymentCompositionId),
-    strategyPackageVersion: finiteString(identity?.strategyPackageVersion),
-    strategyDependencyVersions: packageVersionMap(
-      identity?.strategyDependencyVersions
-    ),
-    runtimePackageVersion: finiteString(identity?.runtimePackageVersion),
-    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 buildEmbeddedLineageScope = ({
   artifact,
   rows,
@@ -300,12 +355,6 @@ var buildEmbeddedLineageScope = ({
       strategyPackageVersion: singleTarget?.strategyPackageVersion ?? null,
       strategyDependencyVersions: singleTarget?.strategyDependencyVersions ?? null,
       runtimePackageVersion: singleTarget?.runtimePackageVersion ?? null,
-      compositionId: null,
-      gitSha: null,
-      gitDirty: null,
-      gateFingerprint: null,
-      configFingerprint: null,
-      contextFingerprint: null,
       maxLossValue: commonRiskValues.size === 1 ? [...commonRiskValues][0] : null,
       strategyScopes: Object.fromEntries(
         targetValues.map((target) => [
@@ -321,12 +370,6 @@ var buildEmbeddedLineageScope = ({
     }
   };
 };
-var belongsToRuntimeLineage = (row, summary) => {
-  if (!summary.identityComplete || !summary.lineageKey) return false;
-  const lineage = asRecord(row.runtimeLineage);
-  if (!lineage) return false;
-  return runtimeLineageKey(lineage) === summary.lineageKey && finiteNumber(lineage.maxLossValue) === summary.maxLossValue;
-};
 var runtimeDeploymentBinding = (artifact) => {
   const deployment = asRecord(asRecord(artifact)?.deployment);
   return {
@@ -508,10 +551,6 @@ var replayCountsForStrategy = (replayComparison, strategy) => {
     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;
@@ -537,6 +576,10 @@ var buildRuntimeScorecard = ({
   strategy = null,
   llmComparatorPolicy = "ai_approved_only"
 }) => {
+  assertCurrentRuntimeEvidenceArtifact(runtimeArtifact);
+  for (const artifact of historyRuntimeArtifacts) {
+    assertCurrentRuntimeEvidenceArtifact(artifact);
+  }
   const scopedRuntimeArtifact = filterArtifactByStrategy(
     runtimeArtifact,
     strategy
@@ -551,7 +594,12 @@ var buildRuntimeScorecard = ({
     rows,
     strategy
   });
-  const runtimeLineage = embeddedLineageScope?.summary ?? buildRuntimeLineageSummary(rows);
+  if (!embeddedLineageScope) {
+    throw new Error(
+      "Runtime scorecard requires the current embedded deployment lineage"
+    );
+  }
+  const runtimeLineage = embeddedLineageScope.summary;
   const window = runtimeWindow(runtimeArtifact);
   const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
   const endTime = finiteNumber(window.endTime) ?? generatedAt;
@@ -599,32 +647,26 @@ var buildRuntimeScorecard = ({
   const lineage = asRecord(replayComparison?.lineage);
   const lineageReason = finiteString(lineage?.reason);
   const calibrationRoot = asRecord(calibrationArtifact) ?? {};
-  const calibrationSummary = asRecord(calibrationRoot.summary);
-  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter(
-    (item) => !embeddedLineageScope || embeddedLineageScope.belongs(item)
-  );
+  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
   const averageSampleMetric = (field) => {
     const values = calibrationSamples.map((sample) => finiteNumber(sample[field])).filter((value) => value != null);
     return values.length ? round(sum(values) / values.length) : null;
   };
-  const fallbackCalibration = strategy ? asRecord(asRecord(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
-  const actualSlippageBps = embeddedLineageScope ? averageSampleMetric("signalToFillAdverseBps") : finiteNumber(asRecord(fallbackCalibration?.signalToFillAdverseBps)?.avg);
-  const residualVsModelBps = embeddedLineageScope ? averageSampleMetric("residualVsCurrentModelBps") : finiteNumber(
-    asRecord(fallbackCalibration?.residualVsCurrentModelBps)?.avg
-  );
+  const actualSlippageBps = averageSampleMetric("signalToFillAdverseBps");
+  const residualVsModelBps = averageSampleMetric("residualVsCurrentModelBps");
   const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
   const historyTrades = dedupeTrades([
     ...scopedHistoryArtifacts,
     scopedRuntimeArtifact
   ]);
   const comparableHistoryTrades = historyTrades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
   );
   const comparableCurrentClosedTrades = currentClosedTrades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
   );
   const comparableFills = rows.trades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && embeddedLineageScope.belongs(trade)
   );
   const currentDistributions = buildDistributions(rows);
   const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {

package/dist/lib/strategyRelease.js

@@ -122,7 +122,7 @@ var buildStrategyLiveDiagnosisFromScorecard = ({
   );
   const orderFailureRate = scorecard.funnel.orderAttempts ? scorecard.funnel.orderFailures / scorecard.funnel.orderAttempts : null;
   const lineage = scorecard.lineage;
-  const lineageComparable = scorecard.parity.lineageReason == null && lineage?.complete === true && lineage.conflicts === false && lineage.compositionId === manifest.composition.compositionId && lineage.gitDirty === false && lineage.gitSha === manifest.composition.gitSha && lineage.configFingerprint === manifest.composition.runtimeConfigFingerprint && lineage.gateFingerprint === manifest.composition.gateFingerprint && lineage.contextFingerprint === manifest.composition.runtimeContextFingerprint;
+  const lineageComparable = scorecard.parity.lineageReason == null && lineage?.complete === true && lineage.conflicts === false && lineage.schemaVersion === 3 && lineage.strategyRevision != null && lineage.deploymentCompositionId != null && lineage.strategyPackageVersion != null && lineage.strategyDependencyVersions != null && lineage.runtimePackageVersion != null;
   const releaseMaxLossValue = manifest.composition.maxLossValue;
   const runtimeMaxLossValue = lineage?.maxLossValue ?? null;
   const riskScaleComparable = Number.isFinite(releaseMaxLossValue) && releaseMaxLossValue > 0 && runtimeMaxLossValue != null && Number.isFinite(runtimeMaxLossValue) && runtimeMaxLossValue > 0;