@tradejs/cli 2.0.19 → 2.0.20

package/dist/scripts/runtimeScorecard.js

@@ -34,8 +34,9 @@ __export(runtimeScorecard_exports, {
   runtimeScorecard: () => runtimeScorecard
 });
 module.exports = __toCommonJS(runtimeScorecard_exports);
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_crypto3 = require("crypto");
+var import_node_path4 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -215,6 +216,71 @@ var extractRuntimeRows = (artifact) => {
     statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord2).filter((item) => item != null)
   };
 };
+var buildRuntimeLineageSummary = (rows) => {
+  const lineageRows = [...rows.evaluations, ...rows.signals, ...rows.trades];
+  const lineages = lineageRows.map((row) => asRecord2(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 = asRecord2(artifact) ?? {};
+  const runtime = runtimePayload(artifact);
+  return {
+    ...root,
+    runtime: {
+      ...runtime,
+      evaluations: asArray(runtime.evaluations).filter(
+        (item) => belongsToStrategy(
+          asRecord2(asRecord2(item)?.evaluation) ?? asRecord2(item) ?? {},
+          strategy
+        )
+      ),
+      signals: asArray(runtime.signals).filter(
+        (item) => belongsToStrategy(
+          asRecord2(asRecord2(item)?.signal) ?? asRecord2(item) ?? {},
+          strategy
+        )
+      ),
+      trades: asArray(runtime.trades).filter(
+        (item) => belongsToStrategy(
+          asRecord2(asRecord2(item)?.trade) ?? asRecord2(item) ?? {},
+          strategy
+        )
+      ),
+      evaluationStatsBuckets: asArray(runtime.evaluationStatsBuckets).filter(
+        (item) => belongsToStrategy(asRecord2(item) ?? {}, strategy)
+      )
+    }
+  };
+};
 var countBy = (items, getter) => {
   const counts = {};
   for (const item of items) {
@@ -333,14 +399,43 @@ var getReplayComparison = (artifact) => {
   const root = asRecord2(artifact) ?? {};
   return asRecord2(asRecord2(root.replay)?.runtimeComparison) ?? null;
 };
+var replayCountsForStrategy = (replayComparison, strategy) => {
+  if (strategy) {
+    const byStrategy = asRecord2(replayComparison?.byStrategy);
+    const strategyCounts = asRecord2(byStrategy?.[strategy]);
+    if (strategyCounts) {
+      return {
+        matched: finiteNumber(strategyCounts.matched) ?? 0,
+        backtestOnly: finiteNumber(strategyCounts.backtestOnly) ?? 0,
+        runtimeOnly: finiteNumber(strategyCounts.runtimeOnly) ?? 0
+      };
+    }
+  }
+  const counts = asRecord2(replayComparison?.counts);
+  return {
+    matched: finiteNumber(counts?.matched) ?? 0,
+    backtestOnly: finiteNumber(counts?.backtestOnly) ?? 0,
+    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;
+  return {
+    rawCoreExpectancy: finiteNumber(root.rawCoreExpectancy),
+    aiGateExpectancy: finiteNumber(root.aiGateExpectancy),
+    regimeCoverage: finiteNumber(root.regimeCoverage)
+  };
+};
 var buildRuntimeScorecard = ({
   runtimeArtifact,
   replayEvidenceArtifact,
   calibrationArtifact,
+  prospectiveEvidenceArtifact,
   historyRuntimeArtifacts = [],
   thresholds = {
     minimumParityRatio: 0.95,
@@ -348,9 +443,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;
@@ -365,6 +470,20 @@ var buildRuntimeScorecard = ({
   })).filter(
     ({ decision }) => decision === "approved" || decision === "rejected"
   );
+  const llmEligibleEvaluations = llmComparatorPolicy === "disabled" ? [] : llmComparatorPolicy === "ai_approved_only" ? signalEvaluations.filter(
+    (evaluation) => finiteString(asRecord2(evaluation.aiAnalysis)?.gateDecision) === "approved"
+  ) : signalEvaluations;
+  const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
+    const analysis = asRecord2(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) => asRecord2(evaluation.allocatorDecision)).filter((item) => item != null);
   const riskDecisions = signalEvaluations.map((evaluation) => asRecord2(evaluation.riskDecision)).filter((item) => item != null);
   const orderAttempts = rows.signals.filter(
@@ -375,27 +494,30 @@ var buildRuntimeScorecard = ({
     return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
   });
   const replayComparison = getReplayComparison(replayEvidenceArtifact);
-  const replayCounts = asRecord2(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 = asRecord2(replayComparison?.lineage);
   const lineageReason = finiteString(lineage?.reason);
-  const calibration = getCalibrationSummary(calibrationArtifact);
+  const calibrationRoot = asRecord2(calibrationArtifact) ?? {};
+  const calibrationSummary = asRecord2(calibrationRoot.summary);
+  const calibration = strategy ? asRecord2(asRecord2(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
   const actualSlippageBps = finiteNumber(
     asRecord2(calibration?.signalToFillAdverseBps)?.avg
   );
   const residualVsModelBps = finiteNumber(
     asRecord2(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(
@@ -454,6 +576,8 @@ var buildRuntimeScorecard = ({
     schemaVersion: 1,
     generatedAt,
     window: { startTime, endTime },
+    strategy,
+    lineage: runtimeLineage,
     promotionStatus,
     thresholds,
     funnel: {
@@ -510,6 +634,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,
@@ -523,6 +665,7 @@ var buildRuntimeScorecard = ({
       actualSignalToFillSlippageBps: actualSlippageBps,
       residualVsCurrentModelBps: residualVsModelBps
     },
+    prospective,
     rolling,
     distributions: currentDistributions,
     distributionChanges: {
@@ -575,6 +718,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}
@@ -604,22 +748,649 @@ ${reactions}
 `;
 };
 
+// src/lib/strategyRelease.ts
+var import_node_crypto2 = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
+var import_types = require("@tradejs/types");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
+var SHA256_RE = /^[a-f0-9]{64}$/;
+var LINEAGE_FINGERPRINT_RE = /^[a-f0-9]{16}$/;
+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}`);
+}
+var assertFingerprint = (value, label) => assert(SHA256_RE.test(value), `${label} must be a lowercase SHA-256`);
+var assertLineageFingerprint = (value, label) => assert(
+  LINEAGE_FINGERPRINT_RE.test(value),
+  `${label} must be a 16-character lowercase lineage fingerprint`
+);
+var releaseReasons = (input) => {
+  const reasons = [];
+  const requiredEvidenceKinds = [
+    "core_research",
+    "ai_gate",
+    "runtime_parity",
+    "execution_calibration"
+  ];
+  if (input.evidence.some((entry) => !entry.verified) || requiredEvidenceKinds.some(
+    (kind) => !input.evidence.some((entry) => entry.kind === kind)
+  )) {
+    reasons.push("EVIDENCE_INCOMPLETE");
+  }
+  if (!input.gates.coreEdgeVerified) reasons.push("NO_VERIFIED_CORE_EDGE");
+  if (!input.gates.aiGateAddsValue) reasons.push("AI_GATE_ADDS_NO_VALUE");
+  if (!input.gates.currentMarketSuitable) {
+    reasons.push("CURRENT_REGIME_UNSUITABLE");
+  }
+  if (!input.gates.runtimeParityVerified) {
+    reasons.push("RUNTIME_PARITY_BLOCKED");
+  }
+  if (!input.gates.executionModelVerified) {
+    reasons.push("EXECUTION_MODEL_UNSAFE");
+  }
+  if (input.researchBudget.hypothesisFamilies >= 3 && !input.gates.coreEdgeVerified) {
+    reasons.push("RESEARCH_BUDGET_EXHAUSTED");
+  }
+  return [...new Set(reasons)];
+};
+var deriveReleaseGates = (evidence) => {
+  const asserted = (name) => {
+    const values = evidence.filter((entry) => entry.verified).map((entry) => entry.releaseAssertions?.[name]).filter((value) => typeof value === "boolean");
+    return values.length > 0 && values.every(Boolean);
+  };
+  return {
+    coreEdgeVerified: asserted("coreEdgeVerified"),
+    aiGateAddsValue: asserted("aiGateAddsValue"),
+    currentMarketSuitable: asserted("currentMarketSuitable"),
+    runtimeParityVerified: asserted("runtimeParityVerified"),
+    executionModelVerified: asserted("executionModelVerified")
+  };
+};
+var verifyEvidenceComposition = (strategy, composition, evidence) => {
+  const requireEqual = (actual, expected, label, artifactId) => assert(
+    actual === expected,
+    `evidence ${artifactId} ${label} does not match the frozen composition`
+  );
+  for (const reference of evidence) {
+    const lineage = reference.lineage;
+    if (reference.kind === "core_research") {
+      requireEqual(
+        lineage?.strategy,
+        strategy,
+        "strategy",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.coreConfigSha256,
+        composition.coreConfigSha256,
+        "coreConfigSha256",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.gitSha,
+        composition.gitSha,
+        "gitSha",
+        reference.artifactId
+      );
+      requireEqual(lineage?.gitDirty, false, "gitDirty", reference.artifactId);
+      requireEqual(
+        lineage?.maxLossValue,
+        composition.maxLossValue,
+        "MAX_LOSS_VALUE",
+        reference.artifactId
+      );
+      assert(
+        lineage?.sourceSha256s.includes(composition.coreExportSha256),
+        `evidence ${reference.artifactId} does not include the frozen core export`
+      );
+      continue;
+    }
+    if (reference.kind === "ai_gate") {
+      requireEqual(
+        lineage?.strategy,
+        strategy,
+        "strategy",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.gitSha,
+        composition.gitSha,
+        "gitSha",
+        reference.artifactId
+      );
+      requireEqual(lineage?.gitDirty, false, "gitDirty", reference.artifactId);
+      requireEqual(
+        lineage?.gateConfigIdsFingerprint,
+        composition.gateConfigIdsFingerprint,
+        "gateConfigIdsFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.gateFingerprint,
+        composition.gateFingerprint,
+        "gateFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.gateContextFingerprint,
+        composition.gateContextFingerprint,
+        "gateContextFingerprint",
+        reference.artifactId
+      );
+      assert(
+        lineage?.sourceSha256s.includes(composition.coreExportSha256),
+        `evidence ${reference.artifactId} does not use the frozen core export`
+      );
+      continue;
+    }
+    if (reference.kind === "runtime_parity") {
+      requireEqual(
+        lineage?.strategy,
+        strategy,
+        "strategy",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.gitSha,
+        composition.gitSha,
+        "gitSha",
+        reference.artifactId
+      );
+      requireEqual(lineage?.gitDirty, false, "gitDirty", reference.artifactId);
+      requireEqual(
+        lineage?.gateFingerprint,
+        composition.gateFingerprint,
+        "gateFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.runtimeConfigFingerprint,
+        composition.runtimeConfigFingerprint,
+        "runtimeConfigFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.runtimeContextFingerprint,
+        composition.runtimeContextFingerprint,
+        "runtimeContextFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.maxLossValue,
+        composition.maxLossValue,
+        "MAX_LOSS_VALUE",
+        reference.artifactId
+      );
+      continue;
+    }
+    if (reference.kind === "execution_calibration") {
+      requireEqual(
+        lineage?.strategy,
+        strategy,
+        "strategy",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.gitSha,
+        composition.gitSha,
+        "gitSha",
+        reference.artifactId
+      );
+      requireEqual(lineage?.gitDirty, false, "gitDirty", reference.artifactId);
+      requireEqual(
+        lineage?.gateFingerprint,
+        composition.gateFingerprint,
+        "gateFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.runtimeConfigFingerprint,
+        composition.runtimeConfigFingerprint,
+        "runtimeConfigFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.runtimeContextFingerprint,
+        composition.runtimeContextFingerprint,
+        "runtimeContextFingerprint",
+        reference.artifactId
+      );
+      requireEqual(
+        lineage?.maxLossValue,
+        composition.maxLossValue,
+        "MAX_LOSS_VALUE",
+        reference.artifactId
+      );
+    }
+  }
+};
+var createStrategyReleaseManifest = (input) => {
+  assert(input.strategy.trim(), "strategy is required");
+  assert(
+    Number.isFinite(input.createdAt),
+    "createdAt must be a finite timestamp"
+  );
+  assert(
+    input.researchBudget.hypothesisFamilies <= 3,
+    "at most 3 hypothesis families are allowed"
+  );
+  assert(
+    input.researchBudget.maximumVariantsPerFamily <= 5,
+    "at most 5 variants per family are allowed"
+  );
+  assert(
+    input.researchBudget.isolatedLongFinalists <= 1,
+    "at most one isolated-long finalist is allowed"
+  );
+  assert(
+    input.researchBudget.aiGateTuningRounds <= 1,
+    "at most one AI-gate tuning round is allowed"
+  );
+  assert(input.marketWindow.cacheOnly, "market window must be cache-only");
+  assert(
+    input.marketWindow.endTime > input.marketWindow.startTime,
+    "market window is invalid"
+  );
+  assert(input.composition.maxLossValue > 0, "MAX_LOSS_VALUE must be positive");
+  assert(
+    input.composition.longEnabled && input.composition.shortEnabled,
+    "LONG and SHORT must both remain enabled"
+  );
+  assert(
+    Number.isInteger(input.monitoring.minimumProspectiveClosedTrades) && input.monitoring.minimumProspectiveClosedTrades > 0,
+    "monitoring.minimumProspectiveClosedTrades must be positive"
+  );
+  assert(
+    Number.isFinite(input.monitoring.minimumParityRatio) && input.monitoring.minimumParityRatio >= 0 && input.monitoring.minimumParityRatio <= 1,
+    "monitoring.minimumParityRatio must be between 0 and 1"
+  );
+  assert(
+    Number.isFinite(input.monitoring.maximumOrderFailureRate) && input.monitoring.maximumOrderFailureRate >= 0 && input.monitoring.maximumOrderFailureRate <= 1,
+    "monitoring.maximumOrderFailureRate must be between 0 and 1"
+  );
+  assert(
+    Number.isFinite(input.monitoring.minimumRegimeCoverage) && input.monitoring.minimumRegimeCoverage >= 0 && input.monitoring.minimumRegimeCoverage <= 1,
+    "monitoring.minimumRegimeCoverage must be between 0 and 1"
+  );
+  assert(
+    input.monitoring.drawdownEnvelopes.length > 0 && input.monitoring.drawdownEnvelopes.every(
+      (entry) => Number.isInteger(entry.days) && entry.days > 0 && Number.isFinite(entry.p95) && Number.isFinite(entry.maximum) && entry.p95 >= 0 && entry.maximum >= entry.p95
+    ),
+    "monitoring drawdown envelopes are invalid"
+  );
+  assertFingerprint(input.composition.coreConfigSha256, "coreConfigSha256");
+  assertFingerprint(input.composition.coreExportSha256, "coreExportSha256");
+  assertLineageFingerprint(
+    input.composition.gateConfigIdsFingerprint,
+    "gateConfigIdsFingerprint"
+  );
+  assertLineageFingerprint(
+    input.composition.runtimeConfigFingerprint,
+    "runtimeConfigFingerprint"
+  );
+  assertLineageFingerprint(
+    input.composition.gateFingerprint,
+    "gateFingerprint"
+  );
+  assertLineageFingerprint(
+    input.composition.gateContextFingerprint,
+    "gateContextFingerprint"
+  );
+  assertLineageFingerprint(
+    input.composition.runtimeContextFingerprint,
+    "runtimeContextFingerprint"
+  );
+  assertFingerprint(input.marketWindow.universeSha256, "universeSha256");
+  for (const entry of input.evidence) {
+    assertFingerprint(entry.sha256, `evidence ${entry.artifactId}`);
+  }
+  verifyEvidenceComposition(input.strategy, input.composition, input.evidence);
+  const evidenceGates = deriveReleaseGates(input.evidence);
+  assert(
+    canonicalStrategyReleaseJson(input.gates) === canonicalStrategyReleaseJson(evidenceGates),
+    "release gates must be derived from verified evidence assertions"
+  );
+  const compositionIdentity = {
+    strategy: input.strategy,
+    gitSha: input.composition.gitSha,
+    coreConfigSha256: input.composition.coreConfigSha256,
+    coreExportSha256: input.composition.coreExportSha256,
+    gateConfigIdsFingerprint: input.composition.gateConfigIdsFingerprint,
+    runtimeConfigFingerprint: input.composition.runtimeConfigFingerprint,
+    gateFingerprint: input.composition.gateFingerprint,
+    gateContextFingerprint: input.composition.gateContextFingerprint,
+    runtimeContextFingerprint: input.composition.runtimeContextFingerprint,
+    maxLossValue: input.composition.maxLossValue
+  };
+  const compositionId = `${safeSegment2(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
+  const reasons = releaseReasons({ ...input, gates: evidenceGates });
+  const economicFailure = reasons.some(
+    (reason) => [
+      "NO_VERIFIED_CORE_EDGE",
+      "AI_GATE_ADDS_NO_VALUE",
+      "CURRENT_REGIME_UNSUITABLE",
+      "RESEARCH_BUDGET_EXHAUSTED"
+    ].includes(reason)
+  );
+  const evidenceFailure = reasons.some(
+    (reason) => [
+      "EVIDENCE_INCOMPLETE",
+      "RUNTIME_PARITY_BLOCKED",
+      "EXECUTION_MODEL_UNSAFE"
+    ].includes(reason)
+  );
+  const verdict = evidenceFailure ? "INSUFFICIENT_EVIDENCE" : economicFailure ? "UNSUITABLE_FOR_CURRENT_MARKET" : "READY_FOR_RUNTIME";
+  const releaseIdentity = {
+    strategy: input.strategy,
+    createdAt: input.createdAt,
+    compositionId,
+    evidence: input.evidence.map(({ kind, artifactId, sha256: sha2562 }) => ({
+      kind,
+      artifactId,
+      sha256: sha2562
+    })),
+    verdict
+  };
+  return {
+    schema: import_types.STRATEGY_RELEASE_SCHEMA,
+    releaseId: `${safeSegment2(input.strategy, "strategy")}_${compactTimestamp(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
+    strategy: input.strategy,
+    createdAt: input.createdAt,
+    composition: { ...input.composition, compositionId },
+    marketWindow: input.marketWindow,
+    researchBudget: input.researchBudget,
+    evidence: input.evidence,
+    gates: evidenceGates,
+    monitoring: input.monitoring,
+    verdict: {
+      status: verdict,
+      reasons,
+      summary: input.summary
+    },
+    prospective: input.prospective
+  };
+};
+var verifyStrategyReleaseEnvelope = async (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",
+    "release envelope schema mismatch"
+  );
+  assert(
+    envelope.releaseId === envelope.manifest?.releaseId,
+    "releaseId mismatch"
+  );
+  assert(
+    strategyReleaseSha256(envelope.manifest) === envelope.manifestSha256,
+    "release manifest checksum mismatch"
+  );
+  const manifest = envelope.manifest;
+  assert(
+    manifest.schema === import_types.STRATEGY_RELEASE_SCHEMA,
+    "manifest schema mismatch"
+  );
+  const rebuilt = createStrategyReleaseManifest({
+    strategy: manifest.strategy,
+    createdAt: manifest.createdAt,
+    composition: {
+      gitSha: manifest.composition.gitSha,
+      coreConfigSha256: manifest.composition.coreConfigSha256,
+      coreExportSha256: manifest.composition.coreExportSha256,
+      gateConfigIdsFingerprint: manifest.composition.gateConfigIdsFingerprint,
+      runtimeConfigFingerprint: manifest.composition.runtimeConfigFingerprint,
+      gateFingerprint: manifest.composition.gateFingerprint,
+      gateContextFingerprint: manifest.composition.gateContextFingerprint,
+      runtimeContextFingerprint: manifest.composition.runtimeContextFingerprint,
+      maxLossValue: manifest.composition.maxLossValue,
+      longEnabled: manifest.composition.longEnabled,
+      shortEnabled: manifest.composition.shortEnabled
+    },
+    marketWindow: manifest.marketWindow,
+    researchBudget: manifest.researchBudget,
+    evidence: manifest.evidence,
+    gates: manifest.gates,
+    monitoring: manifest.monitoring,
+    summary: manifest.verdict.summary,
+    prospective: manifest.prospective
+  });
+  assert(
+    canonicalStrategyReleaseJson(rebuilt) === canonicalStrategyReleaseJson(manifest),
+    "release manifest contains self-declared or inconsistent derived fields"
+  );
+  return envelope;
+};
+var verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
+  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_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
+  await import_promises3.default.writeFile(
+    temporaryPath,
+    `${canonicalStrategyReleaseJson(value)}
+`,
+    "utf8"
+  );
+  await import_promises3.default.rename(temporaryPath, filePath);
+};
+var buildStrategyLiveDiagnosis = (input) => {
+  const minimumClosedTrades = input.minimumClosedTrades ?? 20;
+  const minimumParityRatio = input.minimumParityRatio ?? 0.95;
+  const maximumOrderFailureRate = input.maximumOrderFailureRate ?? 0.05;
+  const minimumRegimeCoverage = input.minimumRegimeCoverage ?? 0.5;
+  const hasExplicitRiskScale = input.riskScaleComparable != null;
+  const comparisonObservedDrawdown = hasExplicitRiskScale ? input.riskScaleComparable ? input.normalizedObservedDrawdown ?? null : null : input.observedDrawdown;
+  const runtimeDivergence = !input.lineageComparable || input.parityRatio != null && input.parityRatio < minimumParityRatio || input.orderFailureRate != null && input.orderFailureRate > maximumOrderFailureRate;
+  const insufficient = input.closedTrades < minimumClosedTrades || input.parityRatio == null || comparisonObservedDrawdown == null || input.historicalDrawdownP95 == null;
+  const expected = !runtimeDivergence && !insufficient && comparisonObservedDrawdown <= input.historicalDrawdownP95;
+  const verdict = runtimeDivergence ? "RUNTIME_DIVERGENCE" : insufficient ? "INSUFFICIENT_EVIDENCE" : expected ? "EXPECTED_DRAWDOWN" : "GENERALIZATION_FAILURE";
+  const attributionIncomplete = input.rawCoreExpectancyDelta == null || input.aiGateAddedValue == null || input.regimeCoverage == null;
+  const attributedVerdict = verdict === "GENERALIZATION_FAILURE" && attributionIncomplete ? "INSUFFICIENT_EVIDENCE" : verdict;
+  const subtype = attributedVerdict !== "GENERALIZATION_FAILURE" ? null : input.rawCoreExpectancyDelta < 0 && input.aiGateAddedValue >= 0 ? "RAW_CORE_DECAY" : input.aiGateAddedValue < 0 ? "AI_GATE_FAILURE" : input.regimeCoverage < minimumRegimeCoverage ? "REGIME_SHIFT" : (input.overfitProbability ?? 0) >= 0.5 ? "SUSPECTED_HISTORICAL_OVERFIT" : "RAW_CORE_DECAY";
+  const explanation = attributedVerdict === "RUNTIME_DIVERGENCE" ? "Runtime cannot be compared economically until lineage, replay parity, and order execution agree with the frozen composition." : attributedVerdict === "EXPECTED_DRAWDOWN" ? "The observed drawdown is within the preregistered equal-length historical drawdown envelope." : attributedVerdict === "GENERALIZATION_FAILURE" ? `Runtime is comparable, but the observed drawdown exceeds the historical envelope (${subtype}).` : attributionIncomplete && verdict === "GENERALIZATION_FAILURE" ? "The drawdown breaches its historical envelope, but matched shadow raw-core, deterministic-gate, or causal regime evidence is missing for attribution." : "There are not enough comparable closed trades and historical drawdown observations for attribution.";
+  const recommendations = attributedVerdict === "RUNTIME_DIVERGENCE" ? [
+    "Resolve lineage and replay parity mismatches before evaluating strategy economics.",
+    "Inspect order failures and execution residuals against the frozen execution model."
+  ] : attributedVerdict === "EXPECTED_DRAWDOWN" ? [
+    "Keep the frozen composition unchanged and continue prospective evidence collection."
+  ] : attributedVerdict === "GENERALIZATION_FAILURE" ? [
+    "Do not retune the live cohort; open a new immutable research lineage.",
+    "Compare raw-core decay, AI-gate added value, and causal regime coverage."
+  ] : [
+    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_types.STRATEGY_LIVE_DIAGNOSIS_SCHEMA,
+    strategy: input.strategy,
+    compositionId: input.compositionId,
+    createdAt: input.createdAt,
+    verdict: attributedVerdict,
+    subtype,
+    confidence: runtimeDivergence || input.closedTrades >= 50 ? "high" : input.closedTrades >= 20 ? "medium" : "low",
+    evidence: {
+      lineageComparable: input.lineageComparable,
+      riskScaleComparable: input.riskScaleComparable ?? false,
+      releaseMaxLossValue: input.releaseMaxLossValue ?? null,
+      runtimeMaxLossValue: input.runtimeMaxLossValue ?? null,
+      riskScaleRatio: input.riskScaleRatio ?? null,
+      parityRatio: input.parityRatio,
+      orderFailureRate: input.orderFailureRate,
+      observedDrawdown: input.observedDrawdown,
+      normalizedObservedDrawdown: input.normalizedObservedDrawdown ?? null,
+      historicalDrawdownP95: input.historicalDrawdownP95,
+      historicalDrawdownMaximum: input.historicalDrawdownMaximum,
+      closedTrades: input.closedTrades,
+      rawCoreExpectancyDelta: input.rawCoreExpectancyDelta,
+      aiGateAddedValue: input.aiGateAddedValue,
+      regimeCoverage: input.regimeCoverage,
+      overfitProbability: input.overfitProbability
+    },
+    explanation,
+    recommendations
+  };
+};
+var buildStrategyLiveDiagnosisFromScorecard = ({
+  manifest,
+  scorecard,
+  days
+}) => {
+  const rolling = scorecard.rolling.find((entry) => entry.days === days);
+  const envelope = manifest.monitoring.drawdownEnvelopes.find(
+    (entry) => entry.days === days
+  );
+  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 releaseMaxLossValue = manifest.composition.maxLossValue;
+  const runtimeMaxLossValue = lineage?.maxLossValue ?? null;
+  const riskScaleComparable = Number.isFinite(releaseMaxLossValue) && releaseMaxLossValue > 0 && runtimeMaxLossValue != null && Number.isFinite(runtimeMaxLossValue) && runtimeMaxLossValue > 0;
+  const riskScaleRatio = riskScaleComparable ? runtimeMaxLossValue / releaseMaxLossValue : null;
+  const normalizedObservedDrawdown = rolling != null && riskScaleRatio != null ? rolling.maxDrawdown / riskScaleRatio : null;
+  const normalizeRuntimeEconomics = (value) => value != null && riskScaleRatio != null ? value / riskScaleRatio : null;
+  return buildStrategyLiveDiagnosis({
+    strategy: manifest.strategy,
+    compositionId: manifest.composition.compositionId,
+    createdAt: scorecard.generatedAt,
+    lineageComparable,
+    riskScaleComparable,
+    releaseMaxLossValue,
+    runtimeMaxLossValue,
+    riskScaleRatio,
+    parityRatio: scorecard.parity.ratio,
+    orderFailureRate,
+    observedDrawdown: rolling?.maxDrawdown ?? null,
+    normalizedObservedDrawdown,
+    historicalDrawdownP95: envelope?.p95 ?? null,
+    historicalDrawdownMaximum: envelope?.maximum ?? null,
+    closedTrades: rolling?.closedTrades ?? 0,
+    rawCoreExpectancyDelta: scorecard.prospective?.rawCoreExpectancy != null && manifest.monitoring.rawCoreExpectancy != null ? normalizeRuntimeEconomics(scorecard.prospective.rawCoreExpectancy) - manifest.monitoring.rawCoreExpectancy : null,
+    aiGateAddedValue: scorecard.prospective?.rawCoreExpectancy != null && scorecard.prospective.aiGateExpectancy != null ? normalizeRuntimeEconomics(scorecard.prospective.aiGateExpectancy) - normalizeRuntimeEconomics(scorecard.prospective.rawCoreExpectancy) : null,
+    regimeCoverage: scorecard.prospective?.regimeCoverage ?? null,
+    overfitProbability: manifest.monitoring.overfitProbability,
+    minimumClosedTrades: manifest.monitoring.minimumProspectiveClosedTrades,
+    minimumParityRatio: manifest.monitoring.minimumParityRatio,
+    maximumOrderFailureRate: manifest.monitoring.maximumOrderFailureRate,
+    minimumRegimeCoverage: manifest.monitoring.minimumRegimeCoverage
+  });
+};
+var publishStrategyLiveDiagnosis = async ({
+  rootDir,
+  diagnosis,
+  sourceArtifacts,
+  composition
+}) => {
+  const diagnosisSha256 = strategyReleaseSha256(diagnosis);
+  const diagnosisId = `${safeSegment2(diagnosis.strategy, "strategy")}_${compactTimestamp(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
+  const envelope = {
+    schema: "tradejs-strategy-live-diagnosis-envelope/v1",
+    diagnosisId,
+    diagnosisSha256,
+    diagnosis
+  };
+  const common = {
+    timestamp: diagnosis.createdAt,
+    artifactId: diagnosisId,
+    artifactSha256: diagnosisSha256,
+    compositionId: diagnosis.compositionId,
+    ...composition ? {
+      gitSha: composition.gitSha,
+      configFingerprint: composition.runtimeConfigFingerprint,
+      gateFingerprint: composition.gateFingerprint,
+      contextFingerprint: composition.runtimeContextFingerprint,
+      maxLossValue: composition.maxLossValue
+    } : {}
+  };
+  const markers = [
+    ...diagnosis.evidence.runtimeMaxLossValue != null && diagnosis.evidence.runtimeMaxLossValue !== diagnosis.evidence.releaseMaxLossValue ? [
+      {
+        ...common,
+        id: `${diagnosisId}:loss`,
+        type: "L",
+        label: "Trade loss value changed",
+        summary: `MAX_LOSS_VALUE ${diagnosis.evidence.runtimeMaxLossValue}`,
+        maxLossValue: diagnosis.evidence.runtimeMaxLossValue,
+        severity: "info"
+      }
+    ] : [],
+    ...diagnosis.verdict === "RUNTIME_DIVERGENCE" ? [
+      {
+        ...common,
+        id: `${diagnosisId}:parity`,
+        type: "P",
+        label: "Runtime parity mismatch",
+        summary: diagnosis.explanation,
+        severity: "blocking"
+      }
+    ] : [],
+    {
+      ...common,
+      id: `${diagnosisId}:recommendation`,
+      type: "R",
+      label: "Live diagnosis",
+      summary: `${diagnosis.verdict}: ${diagnosis.explanation}`,
+      severity: diagnosis.verdict === "EXPECTED_DRAWDOWN" ? "info" : "warning"
+    }
+  ];
+  const markerEnvelope = (0, import_strategyReleaseEvidence.createStrategyEvidenceMarkerEnvelope)({
+    strategy: diagnosis.strategy,
+    createdAt: diagnosis.createdAt,
+    markers,
+    sourceArtifacts
+  });
+  const diagnosisPath = import_node_path3.default.join(
+    rootDir,
+    "diagnoses",
+    safeSegment2(diagnosis.strategy, "strategy"),
+    `${diagnosisId}.json`
+  );
+  const markerPath = import_node_path3.default.join(
+    rootDir,
+    "markers",
+    safeSegment2(diagnosis.strategy, "strategy"),
+    `${markerEnvelope.artifactId}.json`
+  );
+  await Promise.all([
+    writeJsonAtomic(diagnosisPath, envelope),
+    writeJsonAtomic(markerPath, markerEnvelope)
+  ]);
+  await verifyStrategyEvidenceMarkerEnvelope(markerPath);
+  return { diagnosisPath, markerPath, envelope, markerEnvelope };
+};
+
 // src/scripts/runtimeScorecard.ts
-import_args.default.option("runtimeEvidence", "Verified runtime evidence JSON");
-import_args.default.option("replayEvidence", "Replay runtime evidence JSON");
-import_args.default.option("calibration", "Execution calibration JSON");
-import_args.default.option("historyDir", "Directory containing verified evidence bundles");
+import_args.default.option(["u", "runtimeEvidence"], "Verified runtime evidence JSON");
+import_args.default.option(["r", "replayEvidence"], "Replay runtime evidence JSON");
+import_args.default.option(["c", "calibration"], "Execution calibration JSON");
 import_args.default.option(
-  "evidenceDir",
+  ["q", "prospectiveEvidence"],
+  "Verified prospective raw-core/gate/regime summary JSON"
+);
+import_args.default.option(["s", "strategy"], "Exact strategy to isolate in the scorecard");
+import_args.default.option(
+  ["H", "historyDir"],
+  "Directory containing verified evidence bundles"
+);
+import_args.default.option(
+  ["E", "evidenceDir"],
   "Local evidence storage root used for processing receipts",
   process.env.RUNTIME_EVIDENCE_LOCAL_DIR || "data/runtime-evidence"
 );
 import_args.default.option(
-  "deployment",
+  ["d", "deployment"],
   "Deployment id used for processing receipts",
   process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
 );
-import_args.default.option("markProcessed", "Write a processing receipt on success", false);
+import_args.default.option(
+  ["M", "markProcessed"],
+  "Write a processing receipt on success",
+  false
+);
 import_args.default.option(
   ["P", "minimumParityRatio"],
   "Minimum acceptable replay parity",
@@ -637,13 +1408,28 @@ import_args.default.option(
 );
 import_args.default.option(["X", "minimumExpectancy"], "Minimum acceptable 7d expectancy", 0);
 import_args.default.option(["o", "out"], "Output JSON path", "output/runtime-scorecard.json");
+import_args.default.option(
+  ["m", "releaseManifest"],
+  "Verified strategy release envelope JSON"
+);
+import_args.default.option(["D", "diagnosisDays"], "Equal-length release drawdown window", 7);
+import_args.default.option(
+  ["z", "strategyReleaseRoot"],
+  "Publish advisory diagnosis and immutable chart markers under this root"
+);
 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_path3.default.resolve(projectRoot, raw) : null;
+  return raw ? import_node_path4.default.resolve(projectRoot, raw) : null;
+};
+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 readJson = async (filePath) => filePath ? JSON.parse(await import_promises3.default.readFile(filePath, "utf8")) : void 0;
+var sha256File = async (filePath) => (0, import_node_crypto3.createHash)("sha256").update(await import_promises4.default.readFile(filePath)).digest("hex");
 var loadHistoryArtifacts = async (historyDir) => {
   if (!historyDir) return [];
   const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
@@ -660,48 +1446,114 @@ var runtimeScorecard = async () => {
   }
   const replayEvidencePath = resolveOptionalPath(flags.replayEvidence);
   const calibrationPath = resolveOptionalPath(flags.calibration);
+  const prospectiveEvidencePath = resolveOptionalPath(
+    flags.prospectiveEvidence
+  );
   const historyDir = resolveOptionalPath(flags.historyDir);
+  const releaseManifestPath = resolveOptionalPath(flags.releaseManifest);
   const [
     runtimeArtifact,
     replayEvidenceArtifact,
     calibrationArtifact,
+    prospectiveEvidenceArtifact,
     history
   ] = await Promise.all([
     readJson(runtimeEvidencePath),
     readJson(replayEvidencePath),
     readJson(calibrationPath),
+    readJson(prospectiveEvidencePath),
     loadHistoryArtifacts(historyDir)
   ]);
+  assertReportType(runtimeArtifact, "runtime-evidence", "runtimeEvidence");
+  assertReportType(
+    replayEvidenceArtifact,
+    "replay-runtime-evidence",
+    "replayEvidence"
+  );
+  assertReportType(calibrationArtifact, "execution-calibration", "calibration");
+  assertReportType(
+    prospectiveEvidenceArtifact,
+    "strategy-prospective-evidence",
+    "prospectiveEvidence"
+  );
+  const verifiedRelease = releaseManifestPath ? await verifyStrategyReleaseEnvelope(releaseManifestPath) : null;
+  const requestedStrategy = String(flags.strategy ?? "").trim() || null;
+  if (verifiedRelease && requestedStrategy && requestedStrategy !== verifiedRelease.manifest.strategy) {
+    throw new Error(
+      `Requested strategy ${requestedStrategy} does not match release ${verifiedRelease.manifest.strategy}`
+    );
+  }
+  const scorecardStrategy = requestedStrategy ?? verifiedRelease?.manifest.strategy ?? null;
   const scorecard = buildRuntimeScorecard({
     runtimeArtifact,
     replayEvidenceArtifact,
     calibrationArtifact,
+    prospectiveEvidenceArtifact,
     historyRuntimeArtifacts: history,
     thresholds: {
       minimumParityRatio: Number(flags.minimumParityRatio),
       maximumSlippageResidualBps: Number(flags.maximumSlippageResidualBps),
       minimumClosedTrades: Number(flags.minimumClosedTrades),
       minimumExpectancy: Number(flags.minimumExpectancy)
-    }
+    },
+    strategy: scorecardStrategy,
+    llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
   });
-  const outPath = import_node_path3.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_promises3.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
+  await import_promises4.default.mkdir(import_node_path4.default.dirname(outPath), { recursive: true });
   await Promise.all([
-    import_promises3.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+    import_promises4.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-    import_promises3.default.writeFile(
+    import_promises4.default.writeFile(
       markdownPath,
       formatRuntimeScorecardMarkdown(scorecard),
       "utf8"
     )
   ]);
+  const diagnosis = verifiedRelease ? buildStrategyLiveDiagnosisFromScorecard({
+    manifest: verifiedRelease.manifest,
+    scorecard,
+    days: Number(flags.diagnosisDays)
+  }) : null;
+  const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
+  const strategyReleaseRoot = resolveOptionalPath(flags.strategyReleaseRoot);
+  if (diagnosis && diagnosisPath) {
+    await import_promises4.default.writeFile(
+      diagnosisPath,
+      `${JSON.stringify(diagnosis, null, 2)}
+`,
+      "utf8"
+    );
+    if (strategyReleaseRoot) {
+      const sourcePaths = [
+        runtimeEvidencePath,
+        replayEvidencePath,
+        calibrationPath,
+        prospectiveEvidencePath,
+        releaseManifestPath,
+        outPath
+      ].filter((value) => Boolean(value));
+      await publishStrategyLiveDiagnosis({
+        rootDir: strategyReleaseRoot,
+        diagnosis,
+        composition: verifiedRelease?.manifest.composition,
+        sourceArtifacts: await Promise.all(
+          sourcePaths.map(async (sourcePath) => ({
+            artifactId: import_node_path4.default.basename(sourcePath),
+            path: sourcePath,
+            sha256: await sha256File(sourcePath)
+          }))
+        )
+      });
+    }
+  }
   let receiptPath2 = null;
   if (flags.markProcessed) {
     receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-      evidenceRoot: import_node_path3.default.resolve(projectRoot, String(flags.evidenceDir)),
+      evidenceRoot: import_node_path4.default.resolve(projectRoot, String(flags.evidenceDir)),
       deploymentId: String(flags.deployment),
-      bundleDir: import_node_path3.default.dirname(runtimeEvidencePath),
+      bundleDir: import_node_path4.default.dirname(runtimeEvidencePath),
       scorecardPath: outPath
     });
   }
@@ -716,7 +1568,9 @@ var runtimeScorecard = async () => {
         execution: scorecard.execution,
         rolling: scorecard.rolling,
         reactions: scorecard.reactions,
-        receiptPath: receiptPath2
+        receiptPath: receiptPath2,
+        diagnosisPath,
+        diagnosisVerdict: diagnosis?.verdict ?? null
       },
       null,
       2