@tradejs/cli 2.0.18 → 2.0.20

package/dist/scripts/strategyRelease.js

@@ -0,0 +1,1469 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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/scripts/strategyRelease.ts
+var strategyRelease_exports = {};
+__export(strategyRelease_exports, {
+  main: () => main,
+  runStrategyReleaseCommand: () => runStrategyReleaseCommand
+});
+module.exports = __toCommonJS(strategyRelease_exports);
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_fs = require("fs");
+var import_node_readline = require("readline");
+var import_node_path2 = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/strategyRelease.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_types = require("@tradejs/types");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
+var SHA256_RE = /^[a-f0-9]{64}$/;
+var LINEAGE_FINGERPRINT_RE = /^[a-f0-9]{16}$/;
+var DAY_MS = 864e5;
+var REQUIRED_LONG_WINDOWS = [1095, 1460, 1825];
+var REQUIRED_STABLE_TERMINAL_WINDOWS = [365, 180, 90];
+var MIN_RECENT_DIRECTION_REPAIR_TRADES = 20;
+var safeSegment = import_strategyReleaseEvidence.safeStrategyEvidenceSegment;
+var compactTimestamp = import_strategyReleaseEvidence.compactStrategyEvidenceTimestamp;
+var verifyFullPeriodChartArtifact = async (input) => {
+  const artifact = input.chartArtifact;
+  if (!artifact?.path || !SHA256_RE.test(artifact.sha256)) return false;
+  try {
+    const artifactPath = import_node_path.default.resolve(artifact.path);
+    if (await (0, import_strategyReleaseEvidence.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
+      return false;
+    }
+    const report = JSON.parse(await import_promises.default.readFile(artifactPath, "utf8"));
+    return Boolean(
+      report.chart?.persisted === true && report.chart.cardIds?.length && report.errors?.failed === 0 && report.run?.strategy === input.strategy && report.run.mode === "local-deterministic" && report.run.recent === 0 && report.run.since == null && report.run.until == null && Number(report.run.sourceRows) > 0
+    );
+  } catch {
+    return false;
+  }
+};
+var hasExactRuntimeTarget = (target) => Boolean(
+  target?.userName.trim() && target.deploymentId.trim() && target.accountId.trim() && target.strategyConfigName.trim()
+);
+var deriveStrategyReleaseResearchDecision = async (input) => {
+  const blockers = [];
+  const byDays = new Map(
+    input.historicalWindows.map((entry) => [entry.days, entry])
+  );
+  if (REQUIRED_LONG_WINDOWS.some((days) => !byDays.has(days))) {
+    blockers.push("HISTORICAL_MATRIX_INCOMPLETE");
+  }
+  if (REQUIRED_STABLE_TERMINAL_WINDOWS.some((days) => !byDays.has(days))) {
+    blockers.push("HISTORICAL_MATRIX_INCOMPLETE");
+  }
+  const longWindows = REQUIRED_LONG_WINDOWS.map(
+    (days) => byDays.get(days)
+  ).filter((entry) => Boolean(entry));
+  if (longWindows.some(
+    (entry) => entry.pnl <= 0 || entry.profitFactor < 1 || entry.long.pnl <= 0 || entry.long.profitFactor < 1 || entry.short.pnl <= 0 || entry.short.profitFactor < 1
+  )) {
+    blockers.push("HISTORICAL_EDGE_FAILED");
+  }
+  const stableTerminalWindows = REQUIRED_STABLE_TERMINAL_WINDOWS.map(
+    (days) => byDays.get(days)
+  ).filter((entry) => Boolean(entry));
+  if (stableTerminalWindows.some(
+    (entry) => entry.pnl <= 0 || entry.profitFactor < 1 || entry.long.pnl <= 0 || entry.long.profitFactor < 1 || entry.short.pnl <= 0 || entry.short.profitFactor < 1
+  )) {
+    blockers.push("HISTORICAL_EDGE_FAILED");
+  }
+  if (blockers.length) {
+    return {
+      strategy: input.strategy,
+      action: "STOP_RESEARCH",
+      repairAllowed: false,
+      targetDirection: input.recentFailure?.direction ?? null,
+      maxLossValue: null,
+      blockers,
+      summary: "The final composition does not have complete positive ALL/LONG/SHORT evidence on the frozen 3y/4y/max-window matrix."
+    };
+  }
+  const repairAllowed = Boolean(
+    input.recentFailure && input.recentFailure.closedTrades >= MIN_RECENT_DIRECTION_REPAIR_TRADES && input.recentFailure.causalMechanismIdentified && input.recentFailure.repairRoundsUsed === 0 && !input.exposedEvaluation
+  );
+  if (repairAllowed) {
+    return {
+      strategy: input.strategy,
+      action: "REPAIR_RECENT_DIRECTION",
+      repairAllowed: true,
+      targetDirection: input.recentFailure.direction,
+      maxLossValue: null,
+      blockers: [],
+      summary: "Spend the single terminal-direction repair round on the preregistered causal mechanism, then rebuild the full evidence matrix."
+    };
+  }
+  if (!input.candidateImplemented) blockers.push("CANDIDATE_NOT_IMPLEMENTED");
+  if (!await verifyFullPeriodChartArtifact(input)) {
+    blockers.push("FULL_PERIOD_CHART_MISSING");
+  }
+  if (input.forwardTest.maxLossValue !== 1) {
+    blockers.push("FORWARD_RISK_MUST_BE_ONE");
+  }
+  if (blockers.length) {
+    return {
+      strategy: input.strategy,
+      action: "FORWARD_BLOCKED",
+      repairAllowed: false,
+      targetDirection: input.recentFailure?.direction ?? null,
+      maxLossValue: null,
+      blockers,
+      summary: "Complete the frozen candidate implementation and full-period chart before any micro-forward execution."
+    };
+  }
+  if (!input.forwardTest.authorized) {
+    return {
+      strategy: input.strategy,
+      action: "MICRO_FORWARD_READY",
+      repairAllowed: false,
+      targetDirection: input.recentFailure?.direction ?? null,
+      maxLossValue: 1,
+      blockers: ["FORWARD_NOT_AUTHORIZED"],
+      summary: "The candidate is ready for a separately authorized micro-forward test at MAX_LOSS_VALUE=1."
+    };
+  }
+  if (!hasExactRuntimeTarget(input.forwardTest.runtimeTarget)) {
+    return {
+      strategy: input.strategy,
+      action: "FORWARD_BLOCKED",
+      repairAllowed: false,
+      targetDirection: input.recentFailure?.direction ?? null,
+      maxLossValue: 1,
+      blockers: ["RUNTIME_TARGET_UNRESOLVED"],
+      summary: "Forward testing is authorized, but an exact runtime deployment/account target must be resolved first."
+    };
+  }
+  return {
+    strategy: input.strategy,
+    action: "START_MICRO_FORWARD",
+    repairAllowed: false,
+    targetDirection: input.recentFailure?.direction ?? null,
+    maxLossValue: 1,
+    blockers: [],
+    summary: "Start the exact frozen composition as a micro-forward test at MAX_LOSS_VALUE=1; do not retune an underpowered or exposed recent tail."
+  };
+};
+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 = `${safeSegment(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 }) => ({
+      kind,
+      artifactId,
+      sha256
+    })),
+    verdict
+  };
+  return {
+    schema: import_types.STRATEGY_RELEASE_SCHEMA,
+    releaseId: `${safeSegment(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 createStrategyReleaseEnvelope = (manifest) => ({
+  schema: "tradejs-strategy-release-envelope/v1",
+  releaseId: manifest.releaseId,
+  manifestSha256: strategyReleaseSha256(manifest),
+  manifest
+});
+var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
+  const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises.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_promises.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+  return (0, import_strategyReleaseEvidence.verifyStrategyEvidenceMarkerEnvelope)(value);
+};
+var releaseMarkers = (manifest) => {
+  const common = {
+    timestamp: manifest.createdAt,
+    artifactId: manifest.releaseId,
+    artifactSha256: strategyReleaseSha256(manifest),
+    compositionId: manifest.composition.compositionId,
+    gitSha: manifest.composition.gitSha,
+    gateFingerprint: manifest.composition.gateFingerprint,
+    configFingerprint: manifest.composition.runtimeConfigFingerprint,
+    contextFingerprint: manifest.composition.runtimeContextFingerprint,
+    maxLossValue: manifest.composition.maxLossValue
+  };
+  return [
+    {
+      ...common,
+      id: `${manifest.releaseId}:evidence`,
+      type: "E",
+      label: "Evidence frozen",
+      summary: `${manifest.evidence.length} verified release artifacts`,
+      coverage: {
+        startTime: manifest.marketWindow.startTime,
+        endTime: manifest.marketWindow.endTime
+      }
+    },
+    {
+      ...common,
+      id: `${manifest.releaseId}:gate`,
+      type: "G",
+      label: "Composition frozen",
+      summary: manifest.composition.compositionId
+    },
+    {
+      ...common,
+      id: `${manifest.releaseId}:loss`,
+      type: "L",
+      label: "Trade loss value",
+      summary: `MAX_LOSS_VALUE ${manifest.composition.maxLossValue}`,
+      maxLossValue: manifest.composition.maxLossValue
+    },
+    {
+      ...common,
+      id: `${manifest.releaseId}:deployment`,
+      type: "D",
+      label: "Release manifest",
+      summary: manifest.verdict.status,
+      severity: manifest.verdict.status === "READY_FOR_RUNTIME" ? "info" : "blocking"
+    },
+    {
+      ...common,
+      id: `${manifest.releaseId}:recommendation`,
+      type: "R",
+      label: "Release recommendation",
+      summary: manifest.verdict.summary,
+      severity: manifest.verdict.status === "READY_FOR_RUNTIME" ? "info" : "warning"
+    }
+  ];
+};
+var writeJsonAtomic = async (filePath, value) => {
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await import_promises.default.mkdir(import_node_path.default.dirname(filePath), { recursive: true });
+  await import_promises.default.writeFile(
+    temporaryPath,
+    `${canonicalStrategyReleaseJson(value)}
+`,
+    "utf8"
+  );
+  await import_promises.default.rename(temporaryPath, filePath);
+};
+var publishStrategyRelease = async ({
+  rootDir,
+  manifest
+}) => {
+  const envelope = createStrategyReleaseEnvelope(manifest);
+  const markerEnvelope = (0, import_strategyReleaseEvidence.createStrategyEvidenceMarkerEnvelope)({
+    strategy: manifest.strategy,
+    createdAt: manifest.createdAt,
+    markers: releaseMarkers(manifest),
+    sourceArtifacts: manifest.evidence.map((entry) => ({
+      artifactId: entry.artifactId,
+      sha256: entry.sha256,
+      path: entry.path
+    }))
+  });
+  const releasePath = import_node_path.default.join(
+    rootDir,
+    "releases",
+    safeSegment(manifest.strategy, "strategy"),
+    `${manifest.releaseId}.json`
+  );
+  const markerPath = import_node_path.default.join(
+    rootDir,
+    "markers",
+    safeSegment(manifest.strategy, "strategy"),
+    `${markerEnvelope.artifactId}.json`
+  );
+  await Promise.all([
+    writeJsonAtomic(releasePath, envelope),
+    writeJsonAtomic(markerPath, markerEnvelope)
+  ]);
+  await Promise.all([
+    verifyStrategyReleaseEnvelope(releasePath),
+    verifyStrategyEvidenceMarkerEnvelope(markerPath)
+  ]);
+  return { releasePath, markerPath, envelope, markerEnvelope };
+};
+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 realizedDrawdown = (trades, startIndex = 0, endIndex = trades.length) => {
+  let equity = 0;
+  let peak = 0;
+  let maximum = 0;
+  for (let index = startIndex; index < endIndex; index += 1) {
+    const trade = trades[index];
+    equity += trade.netProfit;
+    peak = Math.max(peak, equity);
+    maximum = Math.max(maximum, peak - equity);
+  }
+  return maximum;
+};
+var lowerBoundExitTimestamp = (trades, timestamp) => {
+  let left = 0;
+  let right = trades.length;
+  while (left < right) {
+    const middle = Math.floor((left + right) / 2);
+    if (trades[middle].exitTimestamp < timestamp) left = middle + 1;
+    else right = middle;
+  }
+  return left;
+};
+var percentile = (values, probability) => {
+  const sorted = [...values].sort((left, right) => left - right);
+  const position = (sorted.length - 1) * probability;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] * (upper - position) + sorted[upper] * (position - lower);
+};
+var buildStrategyMonitoringProfile = ({
+  trades,
+  startTime,
+  endTime,
+  days,
+  minimumProspectiveClosedTrades = 20,
+  minimumParityRatio = 0.95,
+  maximumOrderFailureRate = 0.05,
+  minimumRegimeCoverage = 0.5,
+  aiGateExpectancy = null,
+  overfitProbability = null
+}) => {
+  assert(endTime > startTime, "monitoring profile window is invalid");
+  assert(days.length > 0, "monitoring profile days are required");
+  const ordered = trades.filter(
+    (trade) => Number.isFinite(trade.exitTimestamp) && Number.isFinite(trade.netProfit) && trade.exitTimestamp >= startTime && trade.exitTimestamp < endTime
+  ).sort((left, right) => left.exitTimestamp - right.exitTimestamp);
+  const drawdownEnvelopes = [...new Set(days)].sort((left, right) => left - right).map((windowDays) => {
+    assert(
+      Number.isInteger(windowDays) && windowDays > 0,
+      "monitoring profile days must be positive integers"
+    );
+    const duration = windowDays * DAY_MS;
+    assert(
+      endTime - startTime >= duration,
+      `${windowDays}d monitoring window exceeds historical coverage`
+    );
+    const drawdowns = [];
+    for (let windowStart = startTime; windowStart + duration <= endTime; windowStart += DAY_MS) {
+      const windowEnd = windowStart + duration;
+      drawdowns.push(
+        realizedDrawdown(
+          ordered,
+          lowerBoundExitTimestamp(ordered, windowStart),
+          lowerBoundExitTimestamp(ordered, windowEnd)
+        )
+      );
+    }
+    return {
+      days: windowDays,
+      p95: percentile(drawdowns, 0.95),
+      maximum: Math.max(...drawdowns)
+    };
+  });
+  return {
+    minimumProspectiveClosedTrades,
+    minimumParityRatio,
+    maximumOrderFailureRate,
+    minimumRegimeCoverage,
+    drawdownEnvelopes,
+    rawCoreExpectancy: ordered.length ? ordered.reduce((sum, trade) => sum + trade.netProfit, 0) / ordered.length : null,
+    aiGateExpectancy,
+    overfitProbability
+  };
+};
+var publishStrategyLiveDiagnosis = async ({
+  rootDir,
+  diagnosis,
+  sourceArtifacts,
+  composition
+}) => {
+  const diagnosisSha256 = strategyReleaseSha256(diagnosis);
+  const diagnosisId = `${safeSegment(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_path.default.join(
+    rootDir,
+    "diagnoses",
+    safeSegment(diagnosis.strategy, "strategy"),
+    `${diagnosisId}.json`
+  );
+  const markerPath = import_node_path.default.join(
+    rootDir,
+    "markers",
+    safeSegment(diagnosis.strategy, "strategy"),
+    `${markerEnvelope.artifactId}.json`
+  );
+  await Promise.all([
+    writeJsonAtomic(diagnosisPath, envelope),
+    writeJsonAtomic(markerPath, markerEnvelope)
+  ]);
+  await verifyStrategyEvidenceMarkerEnvelope(markerPath);
+  return { diagnosisPath, markerPath, envelope, markerEnvelope };
+};
+var planStrategyEvidenceRetention = ({
+  now,
+  entries,
+  retentionDays = {
+    operational_redis: 3,
+    verbose_payload: 14,
+    verified_runtime_bundle: 90,
+    compact_ledger: null
+  }
+}) => {
+  const keep = [];
+  const remove = [];
+  for (const entry of entries) {
+    const days = retentionDays[entry.kind];
+    if (days == null || !entry.verified || !entry.aggregated || now - entry.createdAt <= days * DAY_MS) {
+      keep.push(entry);
+    } else {
+      remove.push(entry);
+    }
+  }
+  return {
+    keep,
+    delete: remove,
+    bytesReclaimable: remove.reduce((total, entry) => total + entry.bytes, 0)
+  };
+};
+var finiteString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var finiteNumber = (value) => {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+};
+var uniqueStrings = (values) => [
+  ...new Set(
+    values.map(finiteString).filter((value) => value != null)
+  )
+];
+var incompleteEvidenceLineage = () => ({
+  strategy: null,
+  gitSha: null,
+  gitDirty: null,
+  coreConfigSha256: null,
+  gateConfigIdsFingerprint: null,
+  gateFingerprint: null,
+  runtimeConfigFingerprint: null,
+  gateContextFingerprint: null,
+  runtimeContextFingerprint: null,
+  maxLossValue: null,
+  sourceSha256s: []
+});
+var extractEvidenceLineage = ({
+  artifact,
+  reference,
+  nested,
+  array
+}) => {
+  const empty = incompleteEvidenceLineage();
+  if (reference.kind === "core_research") {
+    const variants = array(artifact.variants).map(nested).filter((entry) => entry != null);
+    const selectedCandidateIds = uniqueStrings(
+      array(artifact.comparisons).map(nested).filter(
+        (comparison) => comparison != null && nested(comparison.selection)?.passed === true
+      ).map((comparison) => comparison.candidateId)
+    );
+    const selectedVariants = selectedCandidateIds.length === 1 ? variants.filter(
+      (variant) => finiteString(nested(variant.variant)?.id) === selectedCandidateIds[0]
+    ) : [];
+    const configShas = uniqueStrings(
+      selectedVariants.map((variant) => nested(variant.variant)?.configSha256)
+    );
+    const maxLossValues = [
+      ...new Set(
+        selectedVariants.map(
+          (variant) => finiteNumber(
+            nested(nested(variant.variant)?.resolvedConfig)?.MAX_LOSS_VALUE
+          )
+        ).filter((value) => value != null)
+      )
+    ];
+    const sourceSha256s = uniqueStrings(
+      selectedVariants.flatMap(
+        (variant) => array(variant.files).map((file) => nested(file)?.sha256)
+      )
+    );
+    const resultLineage = nested(artifact.lineage);
+    const strategies = uniqueStrings(
+      selectedVariants.map(
+        (variant) => finiteString(nested(variant.variant)?.configName)?.split(":")[0]
+      )
+    );
+    return {
+      ...empty,
+      strategy: strategies.length === 1 ? strategies[0] : null,
+      gitSha: finiteString(resultLineage?.gitSha),
+      gitDirty: resultLineage?.gitSha != null ? finiteString(resultLineage?.dirtyDiffSha256) != null : null,
+      coreConfigSha256: configShas.length === 1 ? configShas[0] : null,
+      maxLossValue: maxLossValues.length === 1 ? maxLossValues[0] : null,
+      sourceSha256s
+    };
+  }
+  if (reference.kind === "ai_gate") {
+    const lineage = nested(nested(artifact.research)?.lineage);
+    return {
+      ...empty,
+      strategy: finiteString(nested(artifact.run)?.strategy),
+      gitSha: finiteString(lineage?.gitSha),
+      gitDirty: typeof lineage?.gitDirty === "boolean" ? lineage.gitDirty : null,
+      gateConfigIdsFingerprint: finiteString(lineage?.configIdsFingerprint),
+      gateFingerprint: finiteString(lineage?.gateFingerprint),
+      gateContextFingerprint: finiteString(lineage?.contextFingerprint),
+      sourceSha256s: uniqueStrings(array(lineage?.sourceSha256s))
+    };
+  }
+  if (reference.kind === "runtime_parity") {
+    const comparison = nested(nested(artifact.replay)?.runtimeComparison);
+    const replayLineages = array(nested(comparison?.lineage)?.replay).map(nested).map((entry) => nested(entry?.lineage)).filter((entry) => entry != null);
+    const one = (key) => {
+      const values = uniqueStrings(replayLineages.map((entry) => entry[key]));
+      return values.length === 1 ? values[0] : null;
+    };
+    const maxLossValues = [
+      ...new Set(
+        replayLineages.map((entry) => finiteNumber(entry.maxLossValue)).filter((value) => value != null)
+      )
+    ];
+    const dirtyValues = [
+      ...new Set(
+        replayLineages.map((entry) => entry.gitDirty).filter((value) => typeof value === "boolean")
+      )
+    ];
+    return {
+      ...empty,
+      strategy: (() => {
+        const strategies = uniqueStrings(
+          array(nested(comparison?.lineage)?.replay).map(
+            (entry) => nested(entry)?.strategy
+          )
+        );
+        return strategies.length === 1 ? strategies[0] : null;
+      })(),
+      gitSha: one("gitSha"),
+      gitDirty: dirtyValues.length === 1 ? dirtyValues[0] : null,
+      gateFingerprint: one("gateFingerprint"),
+      runtimeConfigFingerprint: one("configFingerprint"),
+      runtimeContextFingerprint: one("contextFingerprint"),
+      maxLossValue: maxLossValues.length === 1 ? maxLossValues[0] : null
+    };
+  }
+  if (reference.kind === "execution_calibration") {
+    const samples = [
+      ...array(artifact.samples),
+      ...array(artifact.replayOnlySamples)
+    ].map(nested);
+    const lineages = samples.map((sample) => nested(sample?.runtimeLineage)).filter((lineage) => lineage != null);
+    const one = (key) => {
+      const values = uniqueStrings(lineages.map((lineage) => lineage[key]));
+      return values.length === 1 ? values[0] : null;
+    };
+    const dirtyValues = [
+      ...new Set(
+        lineages.map((lineage) => lineage.gitDirty).filter((value) => typeof value === "boolean")
+      )
+    ];
+    const maxLossValues = [
+      ...new Set(
+        lineages.map((lineage) => finiteNumber(lineage.maxLossValue)).filter((value) => value != null)
+      )
+    ];
+    return {
+      ...empty,
+      strategy: (() => {
+        const strategies = uniqueStrings(
+          samples.map((sample) => sample?.strategy)
+        );
+        return strategies.length === 1 ? strategies[0] : null;
+      })(),
+      gitSha: one("gitSha"),
+      gitDirty: dirtyValues.length === 1 ? dirtyValues[0] : null,
+      gateFingerprint: one("gateFingerprint"),
+      runtimeConfigFingerprint: one("configFingerprint"),
+      runtimeContextFingerprint: one("contextFingerprint"),
+      maxLossValue: maxLossValues.length === 1 ? maxLossValues[0] : null,
+      sourceSha256s: uniqueStrings([
+        ...array(nested(artifact.sources)?.sha256s),
+        ...array(artifact.sourceSha256s)
+      ])
+    };
+  }
+  return empty;
+};
+var verifyCompletedCoreResearchBundle = async ({
+  artifact,
+  resultPath,
+  resultSha256
+}) => {
+  const researchId = finiteString(artifact.researchId);
+  const specSha256 = finiteString(artifact.specSha256);
+  assert(researchId != null, "core result researchId is required");
+  assert(specSha256 != null, "core result specSha256 is required");
+  const researchDir = import_node_path.default.dirname(resultPath);
+  const manifestPath = import_node_path.default.join(researchDir, "manifest.json");
+  const specPath = import_node_path.default.join(researchDir, "spec.json");
+  const manifestBytes = await import_promises.default.readFile(manifestPath).catch(() => null);
+  const specBytes = await import_promises.default.readFile(specPath).catch(() => null);
+  assert(
+    manifestBytes != null && specBytes != null,
+    "core result must belong to a completed core research bundle"
+  );
+  const manifest = JSON.parse(manifestBytes.toString("utf8"));
+  const artifactHashes = manifest.artifactHashes != null && typeof manifest.artifactHashes === "object" && !Array.isArray(manifest.artifactHashes) ? manifest.artifactHashes : null;
+  const parsedSpec = JSON.parse(specBytes.toString("utf8"));
+  assert(
+    manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
+    "core result is not bound by its completed core research manifest"
+  );
+  for (const [relativePath, expectedSha256] of Object.entries(
+    artifactHashes ?? {}
+  )) {
+    assert(
+      !import_node_path.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+      `core bundle artifact ${relativePath} escapes its research directory`
+    );
+    assert(
+      typeof expectedSha256 === "string" && SHA256_RE.test(expectedSha256),
+      `core bundle artifact ${relativePath} has an invalid checksum`
+    );
+    const actualSha256 = await (0, import_strategyReleaseEvidence.strategyEvidenceFileSha256)(
+      import_node_path.default.join(researchDir, relativePath)
+    );
+    assert(
+      actualSha256 === expectedSha256,
+      `core bundle artifact ${relativePath} checksum mismatch`
+    );
+  }
+};
+async function collectReleaseEvidenceReferences(references) {
+  return Promise.all(
+    references.map(async (reference) => {
+      const actualSha256 = await (0, import_strategyReleaseEvidence.strategyEvidenceFileSha256)(reference.path);
+      assert(
+        actualSha256 === reference.sha256,
+        `evidence ${reference.artifactId} checksum mismatch`
+      );
+      let artifact;
+      try {
+        const parsed = JSON.parse(
+          await import_promises.default.readFile(reference.path, "utf8")
+        );
+        assert(
+          parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
+          `evidence ${reference.artifactId} must be a JSON object`
+        );
+        artifact = parsed;
+      } catch (error) {
+        throw new Error(
+          `Invalid strategy release: evidence ${reference.artifactId} is not valid JSON: ${error.message}`
+        );
+      }
+      const nested = (value) => value != null && typeof value === "object" && !Array.isArray(value) ? value : null;
+      const array = (value) => Array.isArray(value) ? value : [];
+      const semanticallyValid = reference.kind === "core_research" ? artifact.schema === "tradejs-core-research-result/v1" || artifact.schema === "tradejs-core-research-manifest/v1" && artifact.status === "completed" : reference.kind === "ai_gate" ? nested(artifact.run)?.mode === "local-deterministic" && nested(artifact.research)?.lineage != null && nested(artifact.outcome) != null : reference.kind === "runtime_parity" ? artifact.reportType === "replay-runtime-evidence" && nested(nested(artifact.replay)?.runtimeComparison) != null : reference.kind === "execution_calibration" ? artifact.reportType === "execution-calibration" && nested(artifact.summary) != null : reference.kind === "runtime_evidence" ? artifact.reportType === "runtime-evidence" : artifact.reportType === "runtime-scorecard";
+      assert(
+        semanticallyValid,
+        `evidence ${reference.artifactId} does not match ${reference.kind}`
+      );
+      if (reference.kind === "core_research" && artifact.schema === "tradejs-core-research-result/v1") {
+        await verifyCompletedCoreResearchBundle({
+          artifact,
+          resultPath: reference.path,
+          resultSha256: actualSha256
+        });
+      }
+      const releaseAssertions = (() => {
+        if (reference.kind === "core_research") {
+          const evidence = nested(artifact.evidence);
+          const comparisons = array(artifact.comparisons).map(nested).filter((entry) => entry != null);
+          const variants = array(artifact.variants).map(nested).filter((entry) => entry != null);
+          const hasCohorts = (value) => {
+            const cohorts = nested(value);
+            return ["ALL", "LONG", "SHORT"].every(
+              (cohort) => nested(cohorts?.[cohort]) != null
+            );
+          };
+          const directionalEvidenceComplete = variants.length > 0 && variants.every(
+            (variant) => hasCohorts(nested(variant.full)?.cohorts) && array(variant.terminal).every(
+              (window) => hasCohorts(nested(window)?.cohorts)
+            ) && array(variant.folds).every(
+              (window) => hasCohorts(nested(window)?.cohorts)
+            )
+          );
+          const evidenceComplete = [
+            "terminals",
+            "folds",
+            "coldStart",
+            "costStress",
+            "delayStress",
+            "fastNonFast",
+            "runtimeParity"
+          ].every((key) => evidence?.[key] === "present");
+          const reconciled = variants.length > 0 && variants.every(
+            (variant) => nested(variant.reconciliation)?.status === "match"
+          );
+          const selectedCandidateIds = uniqueStrings(
+            comparisons.filter(
+              (comparison) => nested(comparison.selection)?.passed === true
+            ).map((comparison) => comparison.candidateId)
+          );
+          const selected = selectedCandidateIds.length === 1;
+          const finalStage = artifact.stage === "isolated_long" || artifact.stage === "confirmation";
+          const verified = finalStage && evidenceComplete && directionalEvidenceComplete && reconciled && selected;
+          return {
+            coreEdgeVerified: verified,
+            currentMarketSuitable: verified
+          };
+        }
+        if (reference.kind === "ai_gate") {
+          const outcome = nested(artifact.outcome);
+          const approvedRisk = nested(outcome?.approvedRisk);
+          const terminalWindows = array(
+            nested(artifact.research)?.terminalWindows
+          ).map(nested).filter((entry) => entry != null);
+          const hasLongShortDirections = (value) => {
+            const directions = new Map(
+              array(value).map(nested).filter(
+                (entry) => entry != null
+              ).map((entry) => [finiteString(entry.direction), entry])
+            );
+            return ["LONG", "SHORT"].every(
+              (direction) => nested(directions.get(direction)?.summary) != null
+            );
+          };
+          const directionalEvidenceComplete = hasLongShortDirections(artifact.byDirection) && terminalWindows.every(
+            (window) => hasLongShortDirections(window.byDirection)
+          );
+          const terminalsPass = terminalWindows.length > 0 && terminalWindows.every((window) => {
+            const terminalOutcome = nested(window.outcome);
+            return window.complete === true && Number(terminalOutcome?.approved ?? 0) > 0 && Number(
+              nested(terminalOutcome?.approvedRisk)?.totalProfit ?? Number.NEGATIVE_INFINITY
+            ) > 0;
+          });
+          return {
+            aiGateAddsValue: Number(outcome?.expectancyDelta ?? Number.NEGATIVE_INFINITY) > 0 && Number(approvedRisk?.totalProfit ?? Number.NEGATIVE_INFINITY) > 0 && Number(approvedRisk?.profitFactor ?? Number.NEGATIVE_INFINITY) > 1 && directionalEvidenceComplete && terminalsPass
+          };
+        }
+        if (reference.kind === "runtime_parity") {
+          const comparison = nested(nested(artifact.replay)?.runtimeComparison);
+          const counts = nested(comparison?.counts);
+          const matched = Number(counts?.matched ?? 0);
+          const backtestOnly = Number(counts?.backtestOnly ?? 0);
+          const runtimeOnly = Number(counts?.runtimeOnly ?? 0);
+          return {
+            runtimeParityVerified: matched > 0 && backtestOnly === 0 && runtimeOnly === 0 && nested(comparison?.lineage)?.reason == null
+          };
+        }
+        if (reference.kind === "execution_calibration") {
+          const counts = nested(artifact.counts);
+          const all = nested(nested(artifact.summary)?.all);
+          const residual = Number(
+            nested(all?.residualVsCurrentModelBps)?.avg ?? Number.NaN
+          );
+          return {
+            executionModelVerified: Number(counts?.fullTelemetryTrades ?? 0) > 0 && Number.isFinite(residual) && Math.abs(residual) <= 3
+          };
+        }
+        return {};
+      })();
+      const lineage = extractEvidenceLineage({
+        artifact,
+        reference,
+        nested,
+        array
+      });
+      return { ...reference, verified: true, lineage, releaseAssertions };
+    })
+  );
+}
+
+// src/scripts/strategyRelease.ts
+var valueAfter = (argv, name) => {
+  const index = argv.indexOf(name);
+  return index < 0 ? void 0 : argv[index + 1];
+};
+var required = (value, name) => {
+  if (!value?.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+};
+var writeJsonAtomic2 = async (filePath, value) => {
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await import_promises2.default.mkdir(import_node_path2.default.dirname(filePath), { recursive: true });
+  await import_promises2.default.writeFile(
+    temporaryPath,
+    `${JSON.stringify(value, null, 2)}
+`,
+    "utf8"
+  );
+  await import_promises2.default.rename(temporaryPath, filePath);
+};
+var runStrategyReleaseCommand = async (options) => {
+  const inputPath = import_node_path2.default.resolve(options.inputPath);
+  if (options.command === "verify") {
+    const envelope = await verifyStrategyReleaseEnvelope(inputPath);
+    return {
+      kind: "verified",
+      releaseId: envelope.releaseId,
+      verdict: envelope.manifest.verdict.status,
+      inputPath
+    };
+  }
+  if (options.command === "profile") {
+    const startTime = options.startTime;
+    const endTime = options.endTime;
+    if (!Number.isFinite(startTime) || !Number.isFinite(endTime)) {
+      throw new Error("--startTime and --endTime are required");
+    }
+    const trades = [];
+    const lines = (0, import_node_readline.createInterface)({
+      input: (0, import_node_fs.createReadStream)(inputPath, { encoding: "utf8" }),
+      crlfDelay: Infinity
+    });
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      const row = JSON.parse(line);
+      if (options.variantId && row.variantId !== options.variantId) continue;
+      if (Number.isFinite(row.exitTimestamp) && Number.isFinite(row.netProfit)) {
+        trades.push({
+          exitTimestamp: row.exitTimestamp,
+          netProfit: row.netProfit
+        });
+      }
+    }
+    const profile = buildStrategyMonitoringProfile({
+      trades,
+      startTime,
+      endTime,
+      days: options.days?.length ? options.days : [7, 30, 90]
+    });
+    const outputPath = import_node_path2.default.resolve(
+      options.outputPath ?? "output/strategy-monitoring-profile.json"
+    );
+    await writeJsonAtomic2(outputPath, profile);
+    return {
+      kind: "profiled",
+      trades: trades.length,
+      outputPath,
+      profile
+    };
+  }
+  const input = JSON.parse(await import_promises2.default.readFile(inputPath, "utf8"));
+  if (options.command === "decide") {
+    const decision = await deriveStrategyReleaseResearchDecision(input);
+    if (options.outputPath) {
+      await writeJsonAtomic2(import_node_path2.default.resolve(options.outputPath), decision);
+    }
+    return {
+      kind: "decided",
+      ...decision,
+      outputPath: options.outputPath ? import_node_path2.default.resolve(options.outputPath) : null
+    };
+  }
+  if (options.command === "retention") {
+    const plan = planStrategyEvidenceRetention(input);
+    if (options.apply) {
+      await Promise.all(plan.delete.map((entry) => import_promises2.default.rm(entry.path)));
+    }
+    return {
+      kind: "retention",
+      applied: Boolean(options.apply),
+      keepCount: plan.keep.length,
+      deleteCount: plan.delete.length,
+      bytesReclaimable: plan.bytesReclaimable,
+      delete: plan.delete.map((entry) => entry.path)
+    };
+  }
+  if (options.command === "diagnose") {
+    const diagnosis = buildStrategyLiveDiagnosis(input);
+    const outputPath = import_node_path2.default.resolve(
+      options.outputPath ?? "output/strategy-live-diagnosis.json"
+    );
+    await writeJsonAtomic2(outputPath, diagnosis);
+    const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
+      rootDir: import_node_path2.default.resolve(options.rootDir),
+      diagnosis,
+      sourceArtifacts: input.sourceArtifacts ?? []
+    }) : null;
+    return {
+      kind: "diagnosed",
+      verdict: diagnosis.verdict,
+      outputPath,
+      diagnosisPath: published2?.diagnosisPath ?? null,
+      markerPath: published2?.markerPath ?? null
+    };
+  }
+  const manifest = createStrategyReleaseManifest({
+    ...input,
+    evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
+  });
+  const published = await publishStrategyRelease({
+    rootDir: import_node_path2.default.resolve(options.rootDir ?? "data/strategy-release"),
+    manifest
+  });
+  return {
+    kind: "created",
+    releaseId: manifest.releaseId,
+    verdict: manifest.verdict.status,
+    releasePath: published.releasePath,
+    markerPath: published.markerPath
+  };
+};
+var printUsage = () => console.log(`Usage:
+  yarn strategy:release create --input <draft.json> [--root data/strategy-release]
+  yarn strategy:release verify --input <release.json>
+  yarn strategy:release decide --input <research-decision.json> [--out <decision.json>]
+  yarn strategy:release profile --input <trades.jsonl> --variant <id> --startTime <ms> --endTime <ms> [--days 7,30,90] [--out <profile.json>]
+  yarn strategy:release diagnose --input <diagnosis-input.json> [--out output/diagnosis.json]
+  yarn strategy:release retention --input <inventory.json> [--apply]`);
+var main = async () => {
+  const argv = process.argv.slice(2);
+  const command = argv[0];
+  if (!command || ![
+    "create",
+    "verify",
+    "diagnose",
+    "decide",
+    "profile",
+    "retention"
+  ].includes(command)) {
+    printUsage();
+    if (command) process.exitCode = 1;
+    return;
+  }
+  const result = await runStrategyReleaseCommand({
+    command,
+    inputPath: required(valueAfter(argv, "--input"), "--input"),
+    rootDir: valueAfter(argv, "--root"),
+    outputPath: valueAfter(argv, "--out"),
+    apply: argv.includes("--apply"),
+    variantId: valueAfter(argv, "--variant"),
+    startTime: Number(valueAfter(argv, "--startTime")),
+    endTime: Number(valueAfter(argv, "--endTime")),
+    days: valueAfter(argv, "--days")?.split(",").map((entry) => Number(entry.trim()))
+  });
+  console.log(import_chalk.default.green(JSON.stringify(result, null, 2)));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  runStrategyReleaseCommand
+});