@tradejs/cli 2.0.19 → 2.0.20

package/dist/lib/aiPocketSearch.js

@@ -22,15 +22,20 @@ var aiPocketSearch_exports = {};
 __export(aiPocketSearch_exports, {
   buildAiPocketMarkdownReport: () => buildAiPocketMarkdownReport,
   buildAiPocketPredicates: () => buildAiPocketPredicates,
+  classifyAiPocketCoverageFeaturePath: () => classifyAiPocketCoverageFeaturePath,
   classifyAiPocketFeaturePath: () => classifyAiPocketFeaturePath,
+  collectAiPocketFeatureSnapshot: () => collectAiPocketFeatureSnapshot,
   collectAiPocketFeatures: () => collectAiPocketFeatures,
+  resolveAiPocketFeatureCoverage: () => resolveAiPocketFeatureCoverage,
   searchAiPockets: () => searchAiPockets,
+  summarizeAiPocketFeatureCoverage: () => summarizeAiPocketFeatureCoverage,
   summarizeAiPocketRows: () => summarizeAiPocketRows
 });
 module.exports = __toCommonJS(aiPocketSearch_exports);
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
+var PRODUCTION_CANDIDATE_MIN_EVENTS = 25;
 var OUTCOME_SEGMENTS = /* @__PURE__ */ new Set([
   "actual",
   "aiapproved",
@@ -116,6 +121,146 @@ var METADATA_LEAVES = /* @__PURE__ */ new Set([
   "targetsymbol",
   "universe"
 ]);
+var normalizeFeaturePath = (path) => (Array.isArray(path) ? path : path.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+var classifyAiPocketCoverageFeaturePath = (path) => {
+  const segments = normalizeFeaturePath(path);
+  const normalizedPath = segments.join(".");
+  if (segments.some(
+    (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
+  )) {
+    return "cmc";
+  }
+  if (segments.some(
+    (segment) => segment.includes("derivative") || segment.includes("coinalyze")
+  ) || /(?:^|\.)(?:funding|openinterest|oi(?:change|acceleration|divergence)|priceoi|liq(?:long|short|total|imbalance|spike)|liquidation)/.test(
+    normalizedPath
+  )) {
+    return "coinalyze";
+  }
+  return null;
+};
+var hasUsableContextPrimitive = (value) => {
+  if (Array.isArray(value) || value == null) {
+    return false;
+  }
+  if (isFeaturePrimitive(value)) {
+    return typeof value !== "string" || value.toLowerCase() !== "unknown";
+  }
+  if (!isPlainRecord(value)) {
+    return false;
+  }
+  return Object.entries(value).some(([key, child]) => {
+    const normalizedKey = key.toLowerCase();
+    if (DATA_QUALITY_LEAVES.has(normalizedKey) || METADATA_LEAVES.has(normalizedKey) || normalizedKey === "riskflags" || normalizedKey.endsWith("timestamp") || normalizedKey.endsWith("agems")) {
+      return false;
+    }
+    return hasUsableContextPrimitive(child);
+  });
+};
+var isUsableCmcContext = (value) => isPlainRecord(value) && value.available !== false && value.stale !== true && hasUsableContextPrimitive(value);
+var hasUsableCmcContext = (baseContext) => {
+  const relative = isPlainRecord(baseContext?.relative) ? baseContext.relative : null;
+  return Boolean(
+    relative && Object.entries(relative).some(
+      ([key, value]) => key.toLowerCase().startsWith("cmc") && isUsableCmcContext(value)
+    )
+  );
+};
+var isUsableDerivativesContext = (context) => {
+  if (!context) {
+    return false;
+  }
+  const summary = isPlainRecord(context.summary) ? context.summary : null;
+  const riskFlags = Array.isArray(summary?.riskFlags) ? summary.riskFlags.filter(
+    (flag) => typeof flag === "string"
+  ) : [];
+  if (riskFlags.includes("missing_derivatives") || riskFlags.includes("stale_derivatives")) {
+    return false;
+  }
+  const intervals = isPlainRecord(context.intervals) ? context.intervals : null;
+  return Boolean(
+    intervals && Object.values(intervals).some(
+      (interval) => isPlainRecord(interval) && interval.stale !== true && hasUsableContextPrimitive(interval)
+    )
+  );
+};
+var hasUsableCoinalyzeContext = (baseContext) => {
+  const derivatives = isPlainRecord(baseContext?.derivatives) ? baseContext.derivatives : null;
+  if (!derivatives) {
+    return false;
+  }
+  if (isUsableDerivativesContext(derivatives)) {
+    return true;
+  }
+  const targetContext = isPlainRecord(derivatives.targetContext) ? derivatives.targetContext : null;
+  if (isUsableDerivativesContext(targetContext)) {
+    return true;
+  }
+  const referenceContexts = isPlainRecord(derivatives.referenceContexts) ? derivatives.referenceContexts : null;
+  return Boolean(
+    referenceContexts && Object.values(referenceContexts).some(
+      (context) => isUsableDerivativesContext(isPlainRecord(context) ? context : null)
+    )
+  );
+};
+var resolveAiPocketFeatureCoverage = (payload) => {
+  const additionalIndicators = isPlainRecord(payload.additionalIndicators) ? payload.additionalIndicators : null;
+  const baseContext = isPlainRecord(additionalIndicators?.baseContext) ? additionalIndicators.baseContext : null;
+  return {
+    cmc: hasUsableCmcContext(baseContext),
+    coinalyze: hasUsableCoinalyzeContext(baseContext)
+  };
+};
+var isAiPocketCoverageFeatureUsable = ({
+  payload,
+  segments,
+  family,
+  familyCoverage
+}) => {
+  const additionalIndicators = isPlainRecord(payload.additionalIndicators) ? payload.additionalIndicators : null;
+  const baseContext = isPlainRecord(additionalIndicators?.baseContext) ? additionalIndicators.baseContext : null;
+  const baseContextIndex = segments.findIndex(
+    (segment) => segment.toLowerCase() === "basecontext"
+  );
+  if (family === "cmc") {
+    const relative = isPlainRecord(baseContext?.relative) ? baseContext.relative : null;
+    if (relative && baseContextIndex >= 0 && segments[baseContextIndex + 1]?.toLowerCase() === "relative") {
+      const contextKey = segments[baseContextIndex + 2];
+      if (contextKey?.toLowerCase().startsWith("cmc")) {
+        return isUsableCmcContext(relative[contextKey]);
+      }
+    }
+    return familyCoverage.cmc;
+  }
+  const derivatives = isPlainRecord(baseContext?.derivatives) ? baseContext.derivatives : null;
+  if (!derivatives || baseContextIndex < 0 || segments[baseContextIndex + 1]?.toLowerCase() !== "derivatives") {
+    return isUsableDerivativesContext(derivatives);
+  }
+  const branch = segments[baseContextIndex + 2]?.toLowerCase();
+  if (branch == null) {
+    return familyCoverage.coinalyze;
+  }
+  if (branch === "referencecontexts") {
+    const referenceContexts = isPlainRecord(derivatives.referenceContexts) ? derivatives.referenceContexts : null;
+    const symbol = segments[baseContextIndex + 3];
+    if (!symbol) {
+      return Boolean(
+        referenceContexts && Object.values(referenceContexts).some(
+          (context) => isUsableDerivativesContext(isPlainRecord(context) ? context : null)
+        )
+      );
+    }
+    return isUsableDerivativesContext(
+      symbol && referenceContexts && isPlainRecord(referenceContexts[symbol]) ? referenceContexts[symbol] : null
+    );
+  }
+  if (branch === "targetcontext" || branch === "targetderived") {
+    return isUsableDerivativesContext(
+      isPlainRecord(derivatives.targetContext) ? derivatives.targetContext : null
+    );
+  }
+  return isUsableDerivativesContext(derivatives);
+};
 var DERIVED_POLICY_FRAGMENTS = [
   "approval",
   "decisionhint",
@@ -454,7 +599,7 @@ var addSignalRiskDistanceFeatures = ({
     features["derived.takeProfitDistanceBps"] = Math.abs(takeProfitPrice - currentPrice) / Math.abs(currentPrice) * 1e4;
   }
 };
-var collectAiPocketFeatures = ({
+var collectAiPocketFeatureSnapshot = ({
   payload,
   gateContext,
   includeSymbol = false,
@@ -464,6 +609,7 @@ var collectAiPocketFeatures = ({
   onFeatureExcluded
 }) => {
   const features = {};
+  const featureCoverage = resolveAiPocketFeatureCoverage(payload);
   const signal = payload.signal ?? {};
   const source = {
     signal: {
@@ -482,6 +628,19 @@ var collectAiPocketFeatures = ({
     segments: [],
     maxDepth: 8,
     shouldSkipPath: (segments) => {
+      const coverageFamily = classifyAiPocketCoverageFeaturePath(segments);
+      if (featurePolicy === "causal-stationary" && coverageFamily != null && !isAiPocketCoverageFeatureUsable({
+        payload,
+        segments,
+        family: coverageFamily,
+        familyCoverage: featureCoverage
+      })) {
+        onFeatureExcluded?.({
+          path: segments.join("."),
+          classification: "data-quality"
+        });
+        return true;
+      }
       if (featureProfile === "compact" && isCompactFeaturePathSkipped(segments)) {
         return true;
       }
@@ -512,8 +671,9 @@ var collectAiPocketFeatures = ({
   }
   addSignalRiskDistanceFeatures({ features, signal });
   addDirectionalDerivedFeatures(features);
-  return features;
+  return { features, featureCoverage };
 };
+var collectAiPocketFeatures = (options) => collectAiPocketFeatureSnapshot(options).features;
 var formatNumber = (value) => {
   if (Number.isInteger(value)) {
     return String(value);
@@ -779,6 +939,37 @@ var summarizeRowIndexes = (rows, rowIndexes) => {
   return finalizeAiPocketSummary({ rows, accumulator });
 };
 var summarizeAiPocketRows = (rows) => summarizeSelectedRows(rows, rows);
+var summarizeAiPocketFeatureCoverage = (rows, family) => {
+  const coveredRows = rows.filter(
+    (row) => row.featureCoverage?.[family] === true
+  );
+  const allEvents = /* @__PURE__ */ new Set();
+  const coveredEvents = /* @__PURE__ */ new Set();
+  let minTimestamp = null;
+  let maxTimestamp = null;
+  for (const row of rows) {
+    if (isFiniteNumber(row.timestamp)) {
+      allEvents.add(row.timestamp);
+    }
+  }
+  for (const row of coveredRows) {
+    if (!isFiniteNumber(row.timestamp)) {
+      continue;
+    }
+    coveredEvents.add(row.timestamp);
+    minTimestamp = minTimestamp == null ? row.timestamp : Math.min(minTimestamp, row.timestamp);
+    maxTimestamp = maxTimestamp == null ? row.timestamp : Math.max(maxTimestamp, row.timestamp);
+  }
+  return {
+    family,
+    rows: coveredRows.length,
+    rowRatio: rows.length > 0 ? coveredRows.length / rows.length : 0,
+    events: coveredEvents.size,
+    eventRatio: allEvents.size > 0 ? coveredEvents.size / allEvents.size : 0,
+    minTimestamp,
+    maxTimestamp
+  };
+};
 var matchesPredicate = (value, predicate) => {
   if (predicate.kind === "numeric") {
     if (!isFiniteNumber(value)) {
@@ -1092,6 +1283,19 @@ var createPocketResult = (rows, predicates, mask, validationRows, testRows, obje
   const condition = publicPredicates.map((predicate) => predicate.label).join(" AND ");
   const validationScore = validationSummary == null || validationObjectiveSummary == null ? void 0 : validationSummary.support > 0 ? scorePositivePocket(validationObjectiveSummary) - (objective === "standalone" ? 0 : scorePositivePocket(validationObjectiveBaseline)) : Number.NEGATIVE_INFINITY;
   const testScore = testSummary == null || testObjectiveSummary == null ? void 0 : testSummary.support > 0 ? scorePositivePocket(testObjectiveSummary) - (objective === "standalone" ? 0 : scorePositivePocket(testObjectiveBaseline)) : Number.NEGATIVE_INFINITY;
+  const readinessReasons = [];
+  if (summary.events < PRODUCTION_CANDIDATE_MIN_EVENTS) {
+    readinessReasons.push(
+      `train events ${summary.events} < ${PRODUCTION_CANDIDATE_MIN_EVENTS}`
+    );
+  }
+  if (testSummary == null) {
+    readinessReasons.push("untouched test missing");
+  } else if (testSummary.events < PRODUCTION_CANDIDATE_MIN_EVENTS) {
+    readinessReasons.push(
+      `test events ${testSummary.events} < ${PRODUCTION_CANDIDATE_MIN_EVENTS}`
+    );
+  }
   return {
     id: publicPredicates.map((predicate) => predicate.id).join("&&"),
     depth: publicPredicates.length,
@@ -1105,6 +1309,8 @@ var createPocketResult = (rows, predicates, mask, validationRows, testRows, obje
     ...objective !== "standalone" && testObjectiveSummary ? { testObjectiveSummary } : {},
     ...validationScore != null ? { validationScore } : {},
     ...testScore != null ? { testScore } : {},
+    readiness: readinessReasons.length === 0 ? "production-candidate" : "research-only",
+    readinessReasons,
     score: scorePositivePocket(objectiveSummary) - (objective === "standalone" ? 0 : scorePositivePocket(objectiveBaseline))
   };
 };
@@ -1199,6 +1405,43 @@ var diversifyPredicatePool = (predicates, maximum) => {
   }
   return selected;
 };
+var prioritizeRequiredFeatureFamilyPredicates = ({
+  selected,
+  predicates,
+  requiredFeatureFamilies,
+  maximum
+}) => {
+  if (!requiredFeatureFamilies.length) {
+    return selected;
+  }
+  const perFamilyLimit = Math.max(
+    6,
+    Math.floor(maximum * 0.2 / requiredFeatureFamilies.length)
+  );
+  const prioritized = /* @__PURE__ */ new Map();
+  for (const family of requiredFeatureFamilies) {
+    const familyPredicates = predicates.filter(
+      (predicate) => classifyAiPocketCoverageFeaturePath(predicate.featureKey) === family
+    );
+    const positive = [...familyPredicates].sort(
+      (left, right) => scorePositivePocket(right.atomSummary) - scorePositivePocket(left.atomSummary)
+    ).slice(0, Math.ceil(perFamilyLimit * 0.5));
+    const negative = [...familyPredicates].sort(
+      (left, right) => scoreNegativePocket(right.atomSummary) - scoreNegativePocket(left.atomSummary)
+    ).slice(0, Math.ceil(perFamilyLimit * 0.3));
+    const broad = [...familyPredicates].sort((left, right) => right.support - left.support).slice(0, Math.ceil(perFamilyLimit * 0.2));
+    for (const predicate of [...positive, ...negative, ...broad]) {
+      if (prioritized.size >= perFamilyLimit * requiredFeatureFamilies.length) {
+        break;
+      }
+      prioritized.set(predicate.id, predicate);
+    }
+  }
+  for (const predicate of selected) {
+    prioritized.set(predicate.id, predicate);
+  }
+  return [...prioritized.values()].slice(0, maximum);
+};
 var canCombinePredicate = (chosen, candidate) => {
   const sameFeature = chosen.filter(
     (predicate) => predicate.featureKey === candidate.featureKey
@@ -1214,7 +1457,11 @@ var canCombinePredicate = (chosen, candidate) => {
   return lower <= upper;
 };
 var searchAiPockets = (rows, options = {}) => {
-  const minSupport = Math.max(1, Math.trunc(options.minSupport ?? 20));
+  const cadenceProfileOption = options.cadenceProfile;
+  const minSupport = Math.max(
+    1,
+    Math.trunc(cadenceProfileOption?.minSupport ?? options.minSupport ?? 20)
+  );
   const minProfitFactor = Math.max(0, options.minProfitFactor ?? 1.2);
   const minTotalProfit = options.minTotalProfit ?? 0;
   const minWinRate = Math.max(0, options.minWinRate ?? 0);
@@ -1232,17 +1479,27 @@ var searchAiPockets = (rows, options = {}) => {
   const testRows = options.testRows ?? [];
   const minValidationSupport = Math.max(
     0,
-    Math.trunc(options.minValidationSupport ?? 0)
+    Math.trunc(
+      cadenceProfileOption?.minValidationSupport ?? options.minValidationSupport ?? 0
+    )
+  );
+  const minEvents = Math.max(
+    1,
+    Math.trunc(cadenceProfileOption?.minEvents ?? options.minEvents ?? 1)
   );
-  const minEvents = Math.max(1, Math.trunc(options.minEvents ?? 1));
   const minValidationEvents = Math.max(
     0,
-    Math.trunc(options.minValidationEvents ?? 0)
+    Math.trunc(
+      cadenceProfileOption?.minValidationEvents ?? options.minValidationEvents ?? 0
+    )
   );
   const maxBatch = Math.max(1, options.maxBatch ?? Number.POSITIVE_INFINITY);
   const maxEventCountShare = Math.max(
     0,
-    Math.min(1, options.maxEventCountShare ?? 1)
+    Math.min(
+      1,
+      cadenceProfileOption?.maxEventCountShare ?? options.maxEventCountShare ?? 1
+    )
   );
   const maxSymbolCountShare = Math.max(
     0,
@@ -1260,18 +1517,59 @@ var searchAiPockets = (rows, options = {}) => {
   const allowRiskRegression = options.allowRiskRegression === true;
   const requireValidationEligibility = options.requireValidationEligibility === true;
   const dedupeEquivalentSelections = options.dedupeEquivalentSelections !== false;
+  const requiredFeatureFamilies = [
+    ...new Set(options.requiredFeatureFamilies ?? [])
+  ];
+  const excludedFeatureFamilies = [
+    ...new Set(options.excludedFeatureFamilies ?? [])
+  ];
   const progressInterval = Math.max(
     1,
     Math.trunc(options.progressInterval ?? 500)
   );
   const onProgress = options.onProgress;
+  const summarizePartition = (partitionRows) => {
+    const summary = summarizeAiPocketRows(partitionRows);
+    const periodDays = getPeriodDays(partitionRows);
+    return {
+      rows: partitionRows.length,
+      events: summary.events,
+      periodDays,
+      eventsPerDay: periodDays == null ? null : summary.events / periodDays
+    };
+  };
+  const trainPartition = summarizePartition(rows);
+  const validationPartition = summarizePartition(validationRows);
+  const testPartition = summarizePartition(testRows);
+  const cadenceProfile = cadenceProfileOption ?? {
+    mode: "fixed",
+    lowCadence: false,
+    sparseSample: false,
+    adaptiveThresholds: false,
+    trainRows: trainPartition.rows,
+    trainEvents: trainPartition.events,
+    trainPeriodDays: trainPartition.periodDays,
+    trainEventsPerDay: trainPartition.eventsPerDay,
+    validationRows: validationPartition.rows,
+    validationEvents: validationPartition.events,
+    testRows: testPartition.rows,
+    testEvents: testPartition.events,
+    minSupport,
+    minEvents,
+    minValidationSupport,
+    minValidationEvents,
+    maxEventCountShare
+  };
   const predicateResult = buildAiPocketPredicateResult(rows, {
     minSupport,
     maxCategories: options.maxCategories,
     progressInterval,
     onProgress
   });
-  const { predicates } = predicateResult;
+  const predicates = predicateResult.predicates.filter((predicate) => {
+    const family = classifyAiPocketCoverageFeaturePath(predicate.featureKey);
+    return family == null || !excludedFeatureFamilies.includes(family);
+  });
   let lastMaskProgress = 0;
   const emitMaskProgress = (current, done = false) => {
     if (!onProgress) {
@@ -1303,10 +1601,15 @@ var searchAiPockets = (rows, options = {}) => {
   [...predicatePool, ...negativePool, ...supportPool].forEach((predicate) => {
     predicatePoolById.set(predicate.id, predicate);
   });
-  const diversifiedPredicates = diversifyPredicatePool(
-    [...predicatePoolById.values()],
-    maxAtomicPredicates
-  );
+  const diversifiedPredicates = prioritizeRequiredFeatureFamilyPredicates({
+    selected: diversifyPredicatePool(
+      [...predicatePoolById.values()],
+      maxAtomicPredicates
+    ),
+    predicates: scoredPredicates,
+    requiredFeatureFamilies,
+    maximum: maxAtomicPredicates
+  });
   const selectedPredicatePool = diversifiedPredicates.map(
     (predicate) => {
       const { mask, support } = buildMask(rows, predicate);
@@ -1347,6 +1650,13 @@ var searchAiPockets = (rows, options = {}) => {
     });
   };
   const addPocket = (pocketPredicates, mask) => {
+    if (requiredFeatureFamilies.some(
+      (family) => !pocketPredicates.some(
+        (predicate) => classifyAiPocketCoverageFeaturePath(predicate.featureKey) === family
+      )
+    )) {
+      return;
+    }
     const pocket = createPocketResult(
       rows,
       pocketPredicates,
@@ -1464,7 +1774,7 @@ var searchAiPockets = (rows, options = {}) => {
     negativePockets: [...negativePockets.values()].sort(compareNegativePockets).slice(0, top),
     stats: {
       rows: rows.length,
-      featureKeys: predicateResult.featureKeys,
+      featureKeys: new Set(predicates.map((predicate) => predicate.featureKey)).size,
       predicates: predicates.length,
       atomicPredicatesUsed: selectedPredicatePool.length,
       estimatedCombinations,
@@ -1479,6 +1789,9 @@ var searchAiPockets = (rows, options = {}) => {
           )
         )
       ],
+      requiredFeatureFamilies,
+      excludedFeatureFamilies,
+      cadence: cadenceProfile,
       truncated
     }
   };
@@ -1540,16 +1853,20 @@ var pocketRows = (pockets) => pockets.map((pocket, index) => [
   pocket.objectiveSummary ? formatMdNumber(pocket.objectiveSummary.totalProfit) : "n/a",
   formatMdNumber(pocket.summary.maxDrawdown),
   pocket.validationSummary?.support ?? "n/a",
+  pocket.validationSummary?.events ?? "n/a",
   pocket.validationSummary ? formatMdPercent(pocket.validationSummary.winRate) : "n/a",
   pocket.validationSummary ? formatMdNumber(pocket.validationSummary.profitFactor) : "n/a",
   pocket.validationSummary ? formatMdNumber(pocket.validationSummary.totalProfit) : "n/a",
   pocket.testSummary?.support ?? "n/a",
+  pocket.testSummary?.events ?? "n/a",
   pocket.testSummary ? formatMdNumber(pocket.testSummary.profitFactor) : "n/a",
   pocket.testSummary ? formatMdNumber(pocket.testSummary.totalProfit) : "n/a",
   pocket.testObjectiveSummary ? formatMdNumber(pocket.testObjectiveSummary.totalProfit) : "n/a",
   formatMdNumber(pocket.summary.avgTradesPerDay),
   pocket.summary.losingMonths,
   formatMdNumber(pocket.score),
+  pocket.readiness,
+  pocket.readinessReasons.join("; ") || "none",
   pocket.condition
 ]);
 var buildAiPocketMarkdownReport = ({
@@ -1557,6 +1874,7 @@ var buildAiPocketMarkdownReport = ({
   run,
   currentGate,
   pocketSearch,
+  coverageSearches = [],
   errors
 }) => {
   const generatedIso = new Date(generatedAt).toISOString();
@@ -1567,6 +1885,34 @@ var buildAiPocketMarkdownReport = ({
     audit?.paths ?? 0,
     audit?.samples.join(", ") ?? ""
   ]);
+  const pocketTableHeaders = [
+    "#",
+    "N",
+    "Events",
+    "Max batch",
+    "Support",
+    "WR",
+    "PF",
+    "PNL",
+    "Objective PNL",
+    "Max DD",
+    "Val N",
+    "Val Events",
+    "Val WR",
+    "Val PF",
+    "Val PNL",
+    "Test N",
+    "Test Events",
+    "Test PF",
+    "Test PNL",
+    "Test objective PNL",
+    "Trades/Day",
+    "Losing Months",
+    "Score",
+    "Readiness",
+    "Readiness reasons",
+    "Pocket"
+  ];
   const lines = [
     "# AI Pocket Search Report",
     "",
@@ -1590,6 +1936,17 @@ var buildAiPocketMarkdownReport = ({
         ["test_rows", run.testRows],
         ["validation_split", formatMdPercent(run.validationSplit)],
         ["test_split", formatMdPercent(run.testSplit)],
+        ["test_sealed", run.sealedTest?.sealed ? "yes" : "no"],
+        ["sealed_test_rows", run.sealedTest?.rows ?? run.testRows],
+        ["sealed_test_events", run.sealedTest?.events ?? "n/a"],
+        [
+          "sealed_test_start",
+          run.sealedTest?.startTimestamp == null ? "n/a" : new Date(run.sealedTest.startTimestamp).toISOString()
+        ],
+        [
+          "sealed_test_end",
+          run.sealedTest?.endTimestamp == null ? "n/a" : new Date(run.sealedTest.endTimestamp).toISOString()
+        ],
         ["min_validation_support", run.minValidationSupport],
         ["failed", run.failed],
         ["recent", run.recent === 0 ? "all" : run.recent],
@@ -1631,6 +1988,22 @@ var buildAiPocketMarkdownReport = ({
         ["include_gate_context", run.includeGateContext ? "on" : "off"],
         ["feature_profile", run.featureProfile ?? "all"],
         ["feature_policy", run.featurePolicy ?? "all"],
+        ["coverage_mode", run.coverageMode ?? "full"],
+        ["cadence_mode", run.cadenceMode ?? "fixed"],
+        ["low_cadence", pocketSearch.stats.cadence.lowCadence ? "yes" : "no"],
+        [
+          "sparse_sample",
+          pocketSearch.stats.cadence.sparseSample ? "yes" : "no"
+        ],
+        [
+          "adaptive_thresholds",
+          pocketSearch.stats.cadence.adaptiveThresholds ? "on" : "off"
+        ],
+        ["train_events", pocketSearch.stats.cadence.trainEvents],
+        [
+          "train_events_per_day",
+          formatMdNumber(pocketSearch.stats.cadence.trainEventsPerDay, 4)
+        ],
         ["report_path", run.reportPath]
       ]
     ),
@@ -1716,10 +2089,32 @@ var buildAiPocketMarkdownReport = ({
         ["predicates", pocketSearch.stats.predicates],
         ["atomic_used", pocketSearch.stats.atomicPredicatesUsed],
         ["feature_families", pocketSearch.stats.featureFamiliesUsed.join(", ")],
+        [
+          "required_feature_families",
+          pocketSearch.stats.requiredFeatureFamilies.join(", ") || "none"
+        ],
+        [
+          "excluded_feature_families",
+          pocketSearch.stats.excludedFeatureFamilies.join(", ") || "none"
+        ],
         ["estimated_combinations", pocketSearch.stats.estimatedCombinations],
         ["combinations_evaluated", pocketSearch.stats.combinationsEvaluated],
         ["validation_rows", pocketSearch.stats.validationRows],
         ["test_rows", pocketSearch.stats.testRows],
+        ["effective_min_support", pocketSearch.stats.cadence.minSupport],
+        ["effective_min_events", pocketSearch.stats.cadence.minEvents],
+        [
+          "effective_min_validation_support",
+          pocketSearch.stats.cadence.minValidationSupport
+        ],
+        [
+          "effective_min_validation_events",
+          pocketSearch.stats.cadence.minValidationEvents
+        ],
+        [
+          "effective_max_event_count_share",
+          formatMdPercent(pocketSearch.stats.cadence.maxEventCountShare)
+        ],
         [
           "duplicate_pockets_skipped",
           pocketSearch.stats.duplicatePocketsSkipped
@@ -1730,65 +2125,98 @@ var buildAiPocketMarkdownReport = ({
     "",
     "## Top Positive Pockets",
     "",
-    markdownTable(
-      [
-        "#",
-        "N",
-        "Events",
-        "Max batch",
-        "Support",
-        "WR",
-        "PF",
-        "PNL",
-        "Objective PNL",
-        "Max DD",
-        "Val N",
-        "Val WR",
-        "Val PF",
-        "Val PNL",
-        "Test N",
-        "Test PF",
-        "Test PNL",
-        "Test objective PNL",
-        "Trades/Day",
-        "Losing Months",
-        "Score",
-        "Pocket"
-      ],
-      pocketRows(pocketSearch.positivePockets)
-    ),
+    markdownTable(pocketTableHeaders, pocketRows(pocketSearch.positivePockets)),
     "",
     "## Top Loss Pockets",
     "",
-    markdownTable(
-      [
-        "#",
-        "N",
-        "Events",
-        "Max batch",
-        "Support",
-        "WR",
-        "PF",
-        "PNL",
-        "Objective PNL",
-        "Max DD",
-        "Val N",
-        "Val WR",
-        "Val PF",
-        "Val PNL",
-        "Test N",
-        "Test PF",
-        "Test PNL",
-        "Test objective PNL",
-        "Trades/Day",
-        "Losing Months",
-        "Score",
-        "Pocket"
-      ],
-      pocketRows(pocketSearch.negativePockets)
-    ),
+    markdownTable(pocketTableHeaders, pocketRows(pocketSearch.negativePockets)),
     ""
   ];
+  for (const cohort of coverageSearches) {
+    const title = cohort.family === "cmc" ? "CMC" : "Coinalyze";
+    lines.push(
+      `## Coverage Cohort: ${title}`,
+      "",
+      markdownTable(
+        ["Field", "Value"],
+        [
+          ["coverage_rows", cohort.coverage.rows],
+          ["coverage_row_ratio", formatMdPercent(cohort.coverage.rowRatio)],
+          ["coverage_events", cohort.coverage.events],
+          ["coverage_event_ratio", formatMdPercent(cohort.coverage.eventRatio)],
+          [
+            "coverage_from",
+            cohort.coverage.minTimestamp == null ? "n/a" : new Date(cohort.coverage.minTimestamp).toISOString()
+          ],
+          [
+            "coverage_to",
+            cohort.coverage.maxTimestamp == null ? "n/a" : new Date(cohort.coverage.maxTimestamp).toISOString()
+          ],
+          ["scope_rows", cohort.scopeRows],
+          ["train_rows", cohort.trainRows],
+          ["validation_rows", cohort.validationRows],
+          ["test_rows", cohort.testRows],
+          [
+            "low_cadence",
+            cohort.search.stats.cadence.lowCadence ? "yes" : "no"
+          ],
+          [
+            "sparse_sample",
+            cohort.search.stats.cadence.sparseSample ? "yes" : "no"
+          ],
+          [
+            "adaptive_thresholds",
+            cohort.search.stats.cadence.adaptiveThresholds ? "on" : "off"
+          ],
+          ["train_events", cohort.search.stats.cadence.trainEvents],
+          [
+            "train_events_per_day",
+            formatMdNumber(cohort.search.stats.cadence.trainEventsPerDay, 4)
+          ],
+          ["effective_min_support", cohort.search.stats.cadence.minSupport],
+          ["effective_min_events", cohort.search.stats.cadence.minEvents],
+          [
+            "effective_min_validation_support",
+            cohort.search.stats.cadence.minValidationSupport
+          ],
+          [
+            "effective_min_validation_events",
+            cohort.search.stats.cadence.minValidationEvents
+          ],
+          [
+            "effective_max_event_count_share",
+            formatMdPercent(cohort.search.stats.cadence.maxEventCountShare)
+          ],
+          [
+            "required_feature_families",
+            cohort.search.stats.requiredFeatureFamilies.join(", ") || "none"
+          ]
+        ]
+      ),
+      "",
+      `### ${title} Train Baseline`,
+      "",
+      markdownTable(
+        ["Metric", "Value"],
+        summaryMetricRows(cohort.search.baseline)
+      ),
+      "",
+      `### ${title} Top Positive Pockets`,
+      "",
+      markdownTable(
+        pocketTableHeaders,
+        pocketRows(cohort.search.positivePockets)
+      ),
+      "",
+      `### ${title} Top Loss Pockets`,
+      "",
+      markdownTable(
+        pocketTableHeaders,
+        pocketRows(cohort.search.negativePockets)
+      ),
+      ""
+    );
+  }
   if (errors.length) {
     lines.push("## Errors", "", ...errors.map((error) => `- ${error}`), "");
   }
@@ -1799,8 +2227,12 @@ var buildAiPocketMarkdownReport = ({
 0 && (module.exports = {
   buildAiPocketMarkdownReport,
   buildAiPocketPredicates,
+  classifyAiPocketCoverageFeaturePath,
   classifyAiPocketFeaturePath,
+  collectAiPocketFeatureSnapshot,
   collectAiPocketFeatures,
+  resolveAiPocketFeatureCoverage,
   searchAiPockets,
+  summarizeAiPocketFeatureCoverage,
   summarizeAiPocketRows
 });