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

package/dist/scripts/runtimeScorecard.js

@@ -34,9 +34,9 @@ __export(runtimeScorecard_exports, {
   runtimeScorecard: () => runtimeScorecard
 });
 module.exports = __toCommonJS(runtimeScorecard_exports);
-var import_promises6 = __toESM(require("fs/promises"));
-var import_node_crypto5 = require("crypto");
-var import_node_path6 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_crypto4 = require("crypto");
+var import_node_path4 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -44,6 +44,166 @@ var import_chalk = __toESM(require("chalk"));
 var import_node_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
+
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
+  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
+);
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
+var samePackageVersions = (left, right) => {
+  if (!left || !right) return false;
+  const leftEntries = Object.entries(left).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const rightEntries = Object.entries(right).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
+};
+var runtimeLineageMatchesStrategySnapshot = ({
+  lineage,
+  deployment,
+  strategy
+}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
+  lineage.strategyDependencyVersions,
+  strategy.strategyDependencyVersions
+);
+var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
+    throw new Error(
+      "Runtime evidence deployment snapshot is missing or invalid"
+    );
+  }
+  const strategies = value.strategies.map((candidate) => {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
+      throw new Error(
+        "Runtime evidence deployment strategy snapshot is invalid"
+      );
+    }
+    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+      throw new Error(
+        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+      );
+    }
+    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+      throw new Error(
+        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+      );
+    }
+    return candidate;
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (identities.has(strategy.strategyName)) {
+      throw new Error(
+        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+      );
+    }
+    identities.add(strategy.strategyName);
+  }
+  return {
+    ...value,
+    strategies
+  };
+};
+var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
+  const record = isRecord(candidate) ? candidate : null;
+  const nested = record && isRecord(record[field]) ? record[field] : null;
+  return nested ?? record;
+}).filter((record) => record != null);
+var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
+  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
+    throw new Error("Invalid runtime evidence artifact");
+  }
+  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+    artifact.deployment
+  );
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length === 0) {
+    throw new Error("Runtime evidence deployment has no enabled strategies");
+  }
+  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
+  if (!runtime) {
+    throw new Error("Runtime evidence payload is missing");
+  }
+  if ("strategyConfigs" in runtime) {
+    throw new Error(
+      "Runtime evidence payload contains removed strategyConfigs data"
+    );
+  }
+  const rowFields = [
+    "trades",
+    "signals",
+    "evaluations",
+    "lineageScopes"
+  ];
+  for (const field of rowFields) {
+    if (!Array.isArray(runtime[field])) {
+      throw new Error(`Runtime evidence payload ${field} must be an array`);
+    }
+  }
+  const snapshots = new Map(
+    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
+  );
+  const assertRows = (label, rows, lineageField) => {
+    for (const row of rows) {
+      const strategyName = String(row.strategy ?? "").trim();
+      const strategy = snapshots.get(strategyName);
+      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
+        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
+        deployment,
+        strategy
+      })) {
+        throw new Error(
+          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
+        );
+      }
+    }
+  };
+  assertRows(
+    "trade",
+    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "signal",
+    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "evaluation",
+    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "lineage scope",
+    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
+    "lineage"
+  );
+  return deployment;
+};
+
+// src/lib/runtimeEvidenceArtifacts.ts
 var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
 var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
 var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
@@ -113,6 +273,10 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
   if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
     throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
   }
+  const deployment = assertCurrentRuntimeEvidenceArtifact(artifact);
+  if (deployment.id !== manifest.deploymentId) {
+    throw new Error(`Runtime evidence deployment mismatch in ${bundleDir}`);
+  }
   return {
     bundleDir,
     manifestPath,
@@ -152,11 +316,6 @@ var import_node_child_process = require("child_process");
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 var import_node_util = require("util");
-
-// src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
-
-// src/lib/runtimeEvidenceSync.ts
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var safeSegment = (value, fallback) => {
   const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
@@ -198,21 +357,7 @@ var markRuntimeEvidenceBundleProcessed = async ({
 };
 
 // src/lib/runtimeLineage.ts
-var import_node_child_process2 = require("child_process");
-var import_node_crypto3 = require("crypto");
-var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path4 = __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_crypto2 = require("crypto");
-var import_node_module = require("module");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
-
-// src/lib/runtimeLineage.ts
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -224,24 +369,14 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
-var runtimeLineageKey = (lineage) => lineage.schemaVersion === 3 ? [
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var runtimeLineageKey = (lineage) => [
   "v3",
   lineage.deploymentCompositionId,
   lineage.strategyRevision,
   lineage.strategyPackageVersion,
-  `deps:${fingerprintRuntimeValue(
-    lineage.strategyDependencyVersions
-  ).slice(0, 16)}`,
+  `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/runtimeScorecard.ts
@@ -282,75 +417,6 @@ var extractRuntimeRows = (artifact) => {
     statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord2).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) => asRecord2(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,
@@ -462,12 +528,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) => [
@@ -483,12 +543,6 @@ var buildEmbeddedLineageScope = ({
     }
   };
 };
-var belongsToRuntimeLineage = (row, summary) => {
-  if (!summary.identityComplete || !summary.lineageKey) return false;
-  const lineage = asRecord2(row.runtimeLineage);
-  if (!lineage) return false;
-  return runtimeLineageKey(lineage) === summary.lineageKey && finiteNumber(lineage.maxLossValue) === summary.maxLossValue;
-};
 var runtimeDeploymentBinding = (artifact) => {
   const deployment = asRecord2(asRecord2(artifact)?.deployment);
   return {
@@ -670,10 +724,6 @@ var replayCountsForStrategy = (replayComparison, strategy) => {
     runtimeOnly: finiteNumber(counts?.runtimeOnly) ?? 0
   };
 };
-var getCalibrationSummary = (artifact) => {
-  const root = asRecord2(artifact) ?? {};
-  return asRecord2(asRecord2(root.summary)?.all) ?? null;
-};
 var getProspectiveSummary = (artifact) => {
   const root = asRecord2(artifact);
   if (!root || root.reportType !== "strategy-prospective-evidence") return null;
@@ -699,6 +749,10 @@ var buildRuntimeScorecard = ({
   strategy = null,
   llmComparatorPolicy = "ai_approved_only"
 }) => {
+  assertCurrentRuntimeEvidenceArtifact(runtimeArtifact);
+  for (const artifact of historyRuntimeArtifacts) {
+    assertCurrentRuntimeEvidenceArtifact(artifact);
+  }
   const scopedRuntimeArtifact = filterArtifactByStrategy(
     runtimeArtifact,
     strategy
@@ -713,7 +767,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;
@@ -761,32 +820,26 @@ var buildRuntimeScorecard = ({
   const lineage = asRecord2(replayComparison?.lineage);
   const lineageReason = finiteString(lineage?.reason);
   const calibrationRoot = asRecord2(calibrationArtifact) ?? {};
-  const calibrationSummary = asRecord2(calibrationRoot.summary);
-  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord2).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter(
-    (item) => !embeddedLineageScope || embeddedLineageScope.belongs(item)
-  );
+  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord2).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 ? asRecord2(asRecord2(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
-  const actualSlippageBps = embeddedLineageScope ? averageSampleMetric("signalToFillAdverseBps") : finiteNumber(asRecord2(fallbackCalibration?.signalToFillAdverseBps)?.avg);
-  const residualVsModelBps = embeddedLineageScope ? averageSampleMetric("residualVsCurrentModelBps") : finiteNumber(
-    asRecord2(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 }) => {
@@ -1038,14 +1091,14 @@ ${reactions}
 };
 
 // src/lib/strategyRelease.ts
-var import_node_crypto4 = require("crypto");
-var import_promises5 = __toESM(require("fs/promises"));
-var import_node_path5 = __toESM(require("path"));
-var import_types3 = require("@tradejs/types");
-var import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
+var import_node_crypto3 = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
+var import_types2 = require("@tradejs/types");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyRelease/liveDiagnosis.ts
-var import_types2 = require("@tradejs/types");
+var import_types = require("@tradejs/types");
 var buildStrategyLiveDiagnosis = (input) => {
   const minimumClosedTrades = input.minimumClosedTrades ?? 20;
   const minimumParityRatio = input.minimumParityRatio ?? 0.95;
@@ -1073,7 +1126,7 @@ var buildStrategyLiveDiagnosis = (input) => {
     attributionIncomplete && verdict === "GENERALIZATION_FAILURE" ? "Collect matched shadow raw-core, deterministic-gate, and causal regime evidence without changing the composition." : "Collect more verified prospective outcomes without changing the composition."
   ];
   return {
-    schema: import_types2.STRATEGY_LIVE_DIAGNOSIS_SCHEMA,
+    schema: import_types.STRATEGY_LIVE_DIAGNOSIS_SCHEMA,
     strategy: input.strategy,
     compositionId: input.compositionId,
     createdAt: input.createdAt,
@@ -1113,7 +1166,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;
@@ -1150,10 +1203,10 @@ var buildStrategyLiveDiagnosisFromScorecard = ({
 // src/lib/strategyRelease.ts
 var SHA256_RE = /^[a-f0-9]{64}$/;
 var LINEAGE_FINGERPRINT_RE = /^[a-f0-9]{16}$/;
-var safeSegment2 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
-var compactTimestamp = import_strategyReleaseEvidence2.compactStrategyEvidenceTimestamp;
-var canonicalStrategyReleaseJson = (value) => (0, import_strategyReleaseEvidence2.canonicalStrategyEvidenceJson)(value);
-var strategyReleaseSha256 = (value) => (0, import_strategyReleaseEvidence2.strategyEvidenceSha256)(value);
+var safeSegment2 = import_strategyReleaseEvidence.safeStrategyEvidenceSegment;
+var compactTimestamp = import_strategyReleaseEvidence.compactStrategyEvidenceTimestamp;
+var canonicalStrategyReleaseJson = (value) => (0, import_strategyReleaseEvidence.canonicalStrategyEvidenceJson)(value);
+var strategyReleaseSha256 = (value) => (0, import_strategyReleaseEvidence.strategyEvidenceSha256)(value);
 function assert(condition, message) {
   if (!condition) throw new Error(`Invalid strategy release: ${message}`);
 }
@@ -1522,7 +1575,7 @@ var createStrategyReleaseManifest = (input) => {
     verdict
   };
   return {
-    schema: import_types3.STRATEGY_RELEASE_SCHEMA,
+    schema: import_types2.STRATEGY_RELEASE_SCHEMA,
     releaseId: `${safeSegment2(input.strategy, "strategy")}_${compactTimestamp(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
     strategy: input.strategy,
     createdAt: input.createdAt,
@@ -1541,7 +1594,7 @@ var createStrategyReleaseManifest = (input) => {
   };
 };
 var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises5.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises3.default.readFile(valueOrPath, "utf8")) : valueOrPath;
   const envelope = value;
   assert(
     envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -1557,7 +1610,7 @@ var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
   );
   const manifest = envelope.manifest;
   assert(
-    manifest.schema === import_types3.STRATEGY_RELEASE_SCHEMA,
+    manifest.schema === import_types2.STRATEGY_RELEASE_SCHEMA,
     "manifest schema mismatch"
   );
   const rebuilt = createStrategyReleaseManifest({
@@ -1592,19 +1645,19 @@ var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
   return envelope;
 };
 var verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises5.default.readFile(valueOrPath, "utf8")) : valueOrPath;
-  return (0, import_strategyReleaseEvidence2.verifyStrategyEvidenceMarkerEnvelope)(value);
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises3.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  return (0, import_strategyReleaseEvidence.verifyStrategyEvidenceMarkerEnvelope)(value);
 };
 var writeJsonAtomic = async (filePath, value) => {
   const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await import_promises5.default.mkdir(import_node_path5.default.dirname(filePath), { recursive: true });
-  await import_promises5.default.writeFile(
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
+  await import_promises3.default.writeFile(
     temporaryPath,
     `${canonicalStrategyReleaseJson(value)}
 `,
     "utf8"
   );
-  await import_promises5.default.rename(temporaryPath, filePath);
+  await import_promises3.default.rename(temporaryPath, filePath);
 };
 var publishStrategyLiveDiagnosis = async ({
   rootDir,
@@ -1664,19 +1717,19 @@ var publishStrategyLiveDiagnosis = async ({
       severity: diagnosis.verdict === "EXPECTED_DRAWDOWN" ? "info" : "warning"
     }
   ];
-  const markerEnvelope = (0, import_strategyReleaseEvidence2.createStrategyEvidenceMarkerEnvelope)({
+  const markerEnvelope = (0, import_strategyReleaseEvidence.createStrategyEvidenceMarkerEnvelope)({
     strategy: diagnosis.strategy,
     createdAt: diagnosis.createdAt,
     markers,
     sourceArtifacts
   });
-  const diagnosisPath = import_node_path5.default.join(
+  const diagnosisPath = import_node_path3.default.join(
     rootDir,
     "diagnoses",
     safeSegment2(diagnosis.strategy, "strategy"),
     `${diagnosisId}.json`
   );
-  const markerPath = import_node_path5.default.join(
+  const markerPath = import_node_path3.default.join(
     rootDir,
     "markers",
     safeSegment2(diagnosis.strategy, "strategy"),
@@ -1748,15 +1801,15 @@ var flags = import_args.default.parse(process.argv);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var resolveOptionalPath = (value) => {
   const raw = String(value ?? "").trim();
-  return raw ? import_node_path6.default.resolve(projectRoot, raw) : null;
+  return raw ? import_node_path4.default.resolve(projectRoot, raw) : null;
 };
-var readJson = async (filePath) => filePath ? JSON.parse(await import_promises6.default.readFile(filePath, "utf8")) : void 0;
+var readJson = async (filePath) => filePath ? JSON.parse(await import_promises4.default.readFile(filePath, "utf8")) : void 0;
 var assertReportType = (artifact, expected, label) => {
   if (artifact != null && (!artifact || typeof artifact !== "object" || Array.isArray(artifact) || artifact.reportType !== expected)) {
     throw new Error(`${label} must be a ${expected} artifact`);
   }
 };
-var sha256File = async (filePath) => (0, import_node_crypto5.createHash)("sha256").update(await import_promises6.default.readFile(filePath)).digest("hex");
+var sha256File = async (filePath) => (0, import_node_crypto4.createHash)("sha256").update(await import_promises4.default.readFile(filePath)).digest("hex");
 var loadHistoryArtifacts = async (historyDir) => {
   if (!historyDir) return [];
   const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
@@ -1826,13 +1879,13 @@ var runtimeScorecard = async () => {
     strategy: scorecardStrategy,
     llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
   });
-  const outPath = import_node_path6.default.resolve(projectRoot, String(flags.out));
+  const outPath = import_node_path4.default.resolve(projectRoot, String(flags.out));
   const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-  await import_promises6.default.mkdir(import_node_path6.default.dirname(outPath), { recursive: true });
+  await import_promises4.default.mkdir(import_node_path4.default.dirname(outPath), { recursive: true });
   await Promise.all([
-    import_promises6.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+    import_promises4.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-    import_promises6.default.writeFile(
+    import_promises4.default.writeFile(
       markdownPath,
       formatRuntimeScorecardMarkdown(scorecard),
       "utf8"
@@ -1846,7 +1899,7 @@ var runtimeScorecard = async () => {
   const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
   const strategyReleaseRoot = resolveOptionalPath(flags.strategyReleaseRoot);
   if (diagnosis && diagnosisPath) {
-    await import_promises6.default.writeFile(
+    await import_promises4.default.writeFile(
       diagnosisPath,
       `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -1867,7 +1920,7 @@ var runtimeScorecard = async () => {
         composition: verifiedRelease?.manifest.composition,
         sourceArtifacts: await Promise.all(
           sourcePaths.map(async (sourcePath) => ({
-            artifactId: import_node_path6.default.basename(sourcePath),
+            artifactId: import_node_path4.default.basename(sourcePath),
             path: sourcePath,
             sha256: await sha256File(sourcePath)
           }))
@@ -1878,9 +1931,9 @@ var runtimeScorecard = async () => {
   let receiptPath2 = null;
   if (flags.markProcessed) {
     receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-      evidenceRoot: import_node_path6.default.resolve(projectRoot, String(flags.evidenceDir)),
+      evidenceRoot: import_node_path4.default.resolve(projectRoot, String(flags.evidenceDir)),
       deploymentId: String(flags.deployment),
-      bundleDir: import_node_path6.default.dirname(runtimeEvidencePath),
+      bundleDir: import_node_path4.default.dirname(runtimeEvidencePath),
       scorecardPath: outPath
     });
   }