@tradejs/cli 3.0.0 → 3.1.0

package/dist/scripts/strategyRelease.js

@@ -44,11 +44,191 @@ var import_chalk = __toESM(require("chalk"));
 var import_node_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
-var import_types = require("@tradejs/types");
+var import_types2 = require("@tradejs/types");
 var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
+
+// src/lib/strategyRelease/liveDiagnosis.ts
+var import_types = require("@tradejs/types");
+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
+  };
+};
+
+// src/lib/strategyRelease/monitoringProfile.ts
+var DAY_MS = 864e5;
+function assert(condition, message) {
+  if (!condition) throw new Error(`Invalid strategy release: ${message}`);
+}
+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
+  };
+};
+
+// src/lib/strategyRelease/evidenceRetention.ts
+var DAY_MS2 = 864e5;
+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_MS2) {
+      keep.push(entry);
+    } else {
+      remove.push(entry);
+    }
+  }
+  return {
+    keep,
+    delete: remove,
+    bytesReclaimable: remove.reduce((total, entry) => total + entry.bytes, 0)
+  };
+};
+
+// src/lib/strategyRelease.ts
 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;
@@ -187,11 +367,11 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
 };
 var canonicalStrategyReleaseJson = (value) => (0, import_strategyReleaseEvidence.canonicalStrategyEvidenceJson)(value);
 var strategyReleaseSha256 = (value) => (0, import_strategyReleaseEvidence.strategyEvidenceSha256)(value);
-function assert(condition, message) {
+function assert2(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(
+var assertFingerprint = (value, label) => assert2(SHA256_RE.test(value), `${label} must be a lowercase SHA-256`);
+var assertLineageFingerprint = (value, label) => assert2(
   LINEAGE_FINGERPRINT_RE.test(value),
   `${label} must be a 16-character lowercase lineage fingerprint`
 );
@@ -239,7 +419,7 @@ var deriveReleaseGates = (evidence) => {
 };
 var verifyEvidenceComposition = (strategy, composition, evidence) => {
   const directionPolicy = composition.directionPolicy ?? "both";
-  const requireEqual = (actual, expected, label, artifactId) => assert(
+  const requireEqual = (actual, expected, label, artifactId) => assert2(
     actual === expected,
     `evidence ${artifactId} ${label} does not match the frozen composition`
   );
@@ -271,7 +451,7 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
         "MAX_LOSS_VALUE",
         reference.artifactId
       );
-      assert(
+      assert2(
         lineage?.sourceSha256s.includes(composition.coreExportSha256),
         `evidence ${reference.artifactId} does not include the frozen core export`
       );
@@ -317,7 +497,7 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
           reference.artifactId
         );
       }
-      assert(
+      assert2(
         lineage?.sourceSha256s.includes(composition.coreExportSha256),
         `evidence ${reference.artifactId} does not use the frozen core export`
       );
@@ -421,60 +601,60 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
   }
 };
 var createStrategyReleaseManifest = (input) => {
-  assert(input.strategy.trim(), "strategy is required");
-  assert(
+  assert2(input.strategy.trim(), "strategy is required");
+  assert2(
     Number.isFinite(input.createdAt),
     "createdAt must be a finite timestamp"
   );
-  assert(
+  assert2(
     input.researchBudget.hypothesisFamilies <= 3,
     "at most 3 hypothesis families are allowed"
   );
-  assert(
+  assert2(
     input.researchBudget.maximumVariantsPerFamily <= 5,
     "at most 5 variants per family are allowed"
   );
-  assert(
+  assert2(
     input.researchBudget.isolatedLongFinalists <= 1,
     "at most one isolated-long finalist is allowed"
   );
-  assert(
+  assert2(
     input.researchBudget.aiGateTuningRounds <= 1,
     "at most one AI-gate tuning round is allowed"
   );
-  assert(input.marketWindow.cacheOnly, "market window must be cache-only");
-  assert(
+  assert2(input.marketWindow.cacheOnly, "market window must be cache-only");
+  assert2(
     input.marketWindow.endTime > input.marketWindow.startTime,
     "market window is invalid"
   );
-  assert(input.composition.maxLossValue > 0, "MAX_LOSS_VALUE must be positive");
-  assert(
+  assert2(input.composition.maxLossValue > 0, "MAX_LOSS_VALUE must be positive");
+  assert2(
     input.composition.longEnabled && input.composition.shortEnabled,
     "LONG and SHORT must both remain enabled"
   );
-  assert(
+  assert2(
     input.composition.directionPolicy == null || ["both", "long_only", "short_only", "direction_aware"].includes(
       input.composition.directionPolicy
     ),
     "composition.directionPolicy is invalid"
   );
-  assert(
+  assert2(
     Number.isInteger(input.monitoring.minimumProspectiveClosedTrades) && input.monitoring.minimumProspectiveClosedTrades > 0,
     "monitoring.minimumProspectiveClosedTrades must be positive"
   );
-  assert(
+  assert2(
     Number.isFinite(input.monitoring.minimumParityRatio) && input.monitoring.minimumParityRatio >= 0 && input.monitoring.minimumParityRatio <= 1,
     "monitoring.minimumParityRatio must be between 0 and 1"
   );
-  assert(
+  assert2(
     Number.isFinite(input.monitoring.maximumOrderFailureRate) && input.monitoring.maximumOrderFailureRate >= 0 && input.monitoring.maximumOrderFailureRate <= 1,
     "monitoring.maximumOrderFailureRate must be between 0 and 1"
   );
-  assert(
+  assert2(
     Number.isFinite(input.monitoring.minimumRegimeCoverage) && input.monitoring.minimumRegimeCoverage >= 0 && input.monitoring.minimumRegimeCoverage <= 1,
     "monitoring.minimumRegimeCoverage must be between 0 and 1"
   );
-  assert(
+  assert2(
     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
     ),
@@ -508,7 +688,7 @@ var createStrategyReleaseManifest = (input) => {
   }
   verifyEvidenceComposition(input.strategy, input.composition, input.evidence);
   const evidenceGates = deriveReleaseGates(input.evidence);
-  assert(
+  assert2(
     canonicalStrategyReleaseJson(input.gates) === canonicalStrategyReleaseJson(evidenceGates),
     "release gates must be derived from verified evidence assertions"
   );
@@ -555,7 +735,7 @@ var createStrategyReleaseManifest = (input) => {
     verdict
   };
   return {
-    schema: import_types.STRATEGY_RELEASE_SCHEMA,
+    schema: import_types2.STRATEGY_RELEASE_SCHEMA,
     releaseId: `${safeSegment(input.strategy, "strategy")}_${compactTimestamp(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
     strategy: input.strategy,
     createdAt: input.createdAt,
@@ -582,21 +762,21 @@ var createStrategyReleaseEnvelope = (manifest) => ({
 var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
   const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises.default.readFile(valueOrPath, "utf8")) : valueOrPath;
   const envelope = value;
-  assert(
+  assert2(
     envelope?.schema === "tradejs-strategy-release-envelope/v1",
     "release envelope schema mismatch"
   );
-  assert(
+  assert2(
     envelope.releaseId === envelope.manifest?.releaseId,
     "releaseId mismatch"
   );
-  assert(
+  assert2(
     strategyReleaseSha256(envelope.manifest) === envelope.manifestSha256,
     "release manifest checksum mismatch"
   );
   const manifest = envelope.manifest;
-  assert(
-    manifest.schema === import_types.STRATEGY_RELEASE_SCHEMA,
+  assert2(
+    manifest.schema === import_types2.STRATEGY_RELEASE_SCHEMA,
     "manifest schema mismatch"
   );
   const rebuilt = createStrategyReleaseManifest({
@@ -624,7 +804,7 @@ var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
     summary: manifest.verdict.summary,
     prospective: manifest.prospective
   });
-  assert(
+  assert2(
     canonicalStrategyReleaseJson(rebuilt) === canonicalStrategyReleaseJson(manifest),
     "release manifest contains self-declared or inconsistent derived fields"
   );
@@ -739,147 +919,6 @@ var publishStrategyRelease = async ({
   ]);
   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,
@@ -963,32 +1002,6 @@ var publishStrategyLiveDiagnosis = async ({
   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);
@@ -1164,39 +1177,39 @@ var verifyCompletedCoreResearchBundle = async ({
 }) => {
   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");
+  assert2(researchId != null, "core result researchId is required");
+  assert2(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(
+  assert2(
     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(
+  assert2(
     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(
+    assert2(
       !import_node_path.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
       `core bundle artifact ${relativePath} escapes its research directory`
     );
-    assert(
+    assert2(
       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(
+    assert2(
       actualSha256 === expectedSha256,
       `core bundle artifact ${relativePath} checksum mismatch`
     );
@@ -1206,7 +1219,7 @@ async function collectReleaseEvidenceReferences(references) {
   return Promise.all(
     references.map(async (reference) => {
       const actualSha256 = await (0, import_strategyReleaseEvidence.strategyEvidenceFileSha256)(reference.path);
-      assert(
+      assert2(
         actualSha256 === reference.sha256,
         `evidence ${reference.artifactId} checksum mismatch`
       );
@@ -1215,7 +1228,7 @@ async function collectReleaseEvidenceReferences(references) {
         const parsed = JSON.parse(
           await import_promises.default.readFile(reference.path, "utf8")
         );
-        assert(
+        assert2(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
           `evidence ${reference.artifactId} must be a JSON object`
         );
@@ -1228,7 +1241,7 @@ async function collectReleaseEvidenceReferences(references) {
       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(
+      assert2(
         semanticallyValid,
         `evidence ${reference.artifactId} does not match ${reference.kind}`
       );

package/dist/scripts/test-ml.js

@@ -26,7 +26,7 @@ module.exports = __toCommonJS(test_ml_exports);
 var import_config = require("dotenv/config");
 var import_constants = require("@tradejs/core/constants");
 var import_ml = require("@tradejs/infra/ml");
-var import_strategies = require("@tradejs/strategies");
+var import_registry = require("@tradejs/node/registry");
 var now = Date.now();
 var INTERVAL_MIN = 15;
 var CANDLES = import_constants.ML_BASE_CANDLES_WINDOW;
@@ -70,6 +70,12 @@ var buildTrendline = (entryTs, price) => ({
   ]
 });
 var main = async () => {
+  const defaultConfig = await (0, import_registry.getStrategyDefaults)("TrendLine", process.cwd());
+  if (!defaultConfig) {
+    throw new Error(
+      "TrendLine is not registered by the current tradejs.config.ts"
+    );
+  }
   const startTs = now - CANDLES * INTERVAL_MIN * 6e4;
   const candles = makeCandles(120, startTs);
   const btcCandles = makeCandles(42e3, startTs);
@@ -120,7 +126,7 @@ var main = async () => {
       volume24h: makeSeries(10, 8e3, 200)
     }
   };
-  const { TRENDLINE, HIGHS, LOWS, ML_THRESHOLD } = import_strategies.trendLineDefaultConfig;
+  const { TRENDLINE, HIGHS, LOWS, ML_THRESHOLD } = defaultConfig;
   const fullRow = (0, import_ml.buildMlTrainingRow)(
     {
       signal,