@tradejs/cli 2.0.14 → 2.0.16

package/dist/lib/aiPocketSearch.js

@@ -22,6 +22,7 @@ var aiPocketSearch_exports = {};
 __export(aiPocketSearch_exports, {
   buildAiPocketMarkdownReport: () => buildAiPocketMarkdownReport,
   buildAiPocketPredicates: () => buildAiPocketPredicates,
+  classifyAiPocketFeaturePath: () => classifyAiPocketFeaturePath,
   collectAiPocketFeatures: () => collectAiPocketFeatures,
   searchAiPockets: () => searchAiPockets,
   summarizeAiPocketRows: () => summarizeAiPocketRows
@@ -88,6 +89,115 @@ var normalizeFeaturePrimitive = (value) => {
   return value;
 };
 var isOutcomePath = (segments) => segments.some((segment) => OUTCOME_SEGMENTS.has(segment.toLowerCase()));
+var DATA_QUALITY_LEAVES = /* @__PURE__ */ new Set([
+  "age",
+  "agems",
+  "available",
+  "asofts",
+  "calcbars",
+  "coverage",
+  "latestindex",
+  "points",
+  "rowcount",
+  "rows",
+  "stale",
+  "timestamp",
+  "windowendts"
+]);
+var METADATA_LEAVES = /* @__PURE__ */ new Set([
+  "connector",
+  "exchange",
+  "fingerprint",
+  "interval",
+  "provider",
+  "source",
+  "strategy",
+  "symbol",
+  "targetsymbol",
+  "universe"
+]);
+var DERIVED_POLICY_FRAGMENTS = [
+  "approval",
+  "decisionhint",
+  "gatefeature",
+  "gatescore",
+  "hardblock",
+  "qualitycap",
+  "recoverycandidate",
+  "rejectreason",
+  "riskflag"
+];
+var RAW_NONSTATIONARY_LEAVES = /* @__PURE__ */ new Set([
+  "activeassets",
+  "activemarkets",
+  "close",
+  "current",
+  "currentprice",
+  "high",
+  "indexprice",
+  "liquidations",
+  "liquidationsusd",
+  "low",
+  "marketcap",
+  "marketcapusd",
+  "notional",
+  "open",
+  "openinterest",
+  "openinterestusd",
+  "price",
+  "quotevolume",
+  "turnover",
+  "turnoverusd",
+  "volume",
+  "volumeusd",
+  "vwap"
+]);
+var classifyAiPocketFeaturePath = (path) => {
+  const segments = (Array.isArray(path) ? path : path.split(".")).filter(
+    Boolean
+  );
+  const normalized = segments.map((segment) => segment.toLowerCase());
+  const leaf = normalized.at(-1) ?? "";
+  const normalizedPath = normalized.join(".");
+  const strategyGateFeaturesIndex = normalized.findIndex(
+    (segment) => segment !== "gatefeatures" && segment.endsWith("gatefeatures")
+  );
+  const strategyGateFeaturePath = normalized.slice(
+    strategyGateFeaturesIndex + 1
+  );
+  const isStrategySetupEvidence = normalized.includes("basecontext") && strategyGateFeaturesIndex >= 0 && (strategyGateFeaturePath.length === 0 || strategyGateFeaturePath.some(
+    (segment) => segment === "geometry" || segment === "path"
+  ));
+  if (DATA_QUALITY_LEAVES.has(leaf) || leaf.endsWith("timestamp") || leaf.endsWith("agems") || normalized.some(
+    (segment) => ["availability", "dataquality", "freshness"].includes(segment)
+  )) {
+    return "data-quality";
+  }
+  if (METADATA_LEAVES.has(leaf) || leaf.endsWith("fingerprint") || normalized.some((segment) => segment === "metadata")) {
+    return "metadata";
+  }
+  if (DERIVED_POLICY_FRAGMENTS.some(
+    (fragment) => !(fragment === "gatefeature" && isStrategySetupEvidence) && normalizedPath.includes(fragment)
+  )) {
+    return "derived-policy";
+  }
+  const isDerivedFeature = normalized[0] === "derived";
+  const isNormalizedLeaf = /(alpha|bps|change|delta|direction|distance|pct|percentile|ratio|regime|return|share|slope|trend|zscore)/.test(
+    leaf
+  );
+  const isRawMovingAverage = /^(?:ema|ma|sma|wma)(?:fast|slow|\d+)$/.test(leaf);
+  const isRawAbsolutePositioning = /^(?:liq(?:long|net|short|total)|oi|openinterest(?:long|short)?)$/.test(
+    leaf
+  );
+  const isRawAbsoluteMeasure = /(?:liquidations?|marketcap|notional|openinterest|price|turnover|volume)$/.test(
+    leaf
+  );
+  const isRawStructureLevel = leaf === "level" && normalized.includes("structure");
+  if (!isDerivedFeature && !isNormalizedLeaf && (RAW_NONSTATIONARY_LEAVES.has(leaf) || isRawMovingAverage || isRawAbsolutePositioning || isRawAbsoluteMeasure || isRawStructureLevel)) {
+    return "raw-nonstationary";
+  }
+  return "eligible";
+};
 var isFeaturePathPrefix = (segments, prefix) => prefix.every((segment, index) => segments[index] === segment);
 var isCompactFeaturePathSkipped = (segments) => {
   if (!segments.length) {
@@ -349,7 +459,9 @@ var collectAiPocketFeatures = ({
   gateContext,
   includeSymbol = false,
   includeGateContext = false,
-  featureProfile = "all"
+  featureProfile = "all",
+  featurePolicy = "all",
+  onFeatureExcluded
 }) => {
   const features = {};
   const signal = payload.signal ?? {};
@@ -369,8 +481,35 @@ var collectAiPocketFeatures = ({
     value: source,
     segments: [],
     maxDepth: 8,
-    shouldSkipPath: featureProfile === "compact" ? isCompactFeaturePathSkipped : void 0
+    shouldSkipPath: (segments) => {
+      if (featureProfile === "compact" && isCompactFeaturePathSkipped(segments)) {
+        return true;
+      }
+      if (featurePolicy !== "causal-stationary") {
+        return false;
+      }
+      const classification = classifyAiPocketFeaturePath(segments);
+      if (classification === "eligible") {
+        return false;
+      }
+      onFeatureExcluded?.({
+        path: segments.join("."),
+        classification
+      });
+      return true;
+    }
   });
+  if (featurePolicy === "causal-stationary") {
+    for (const [key, value] of Object.entries(features)) {
+      if (value === null) {
+        onFeatureExcluded?.({
+          path: key,
+          classification: "data-quality"
+        });
+        delete features[key];
+      }
+    }
+  }
   addSignalRiskDistanceFeatures({ features, signal });
   addDirectionalDerivedFeatures(features);
   return features;
@@ -423,6 +562,7 @@ var createSummaryAccumulator = () => ({
   directionCounts: /* @__PURE__ */ new Map(),
   symbolCounts: /* @__PURE__ */ new Map(),
   monthProfits: /* @__PURE__ */ new Map(),
+  eventStats: /* @__PURE__ */ new Map(),
   equityPoints: []
 });
 var addSummaryRow = (accumulator, row) => {
@@ -448,6 +588,14 @@ var addSummaryRow = (accumulator, row) => {
   symbolBucket.totalProfit += profit;
   accumulator.symbolCounts.set(symbol, symbolBucket);
   const timestamp = typeof row.timestamp === "number" && Number.isFinite(row.timestamp) ? row.timestamp : Number.POSITIVE_INFINITY;
+  const eventKey = Number.isFinite(timestamp) ? String(timestamp) : `UNKNOWN:${accumulator.support}`;
+  const event = accumulator.eventStats.get(eventKey) ?? {
+    count: 0,
+    totalProfit: 0
+  };
+  event.count += 1;
+  event.totalProfit += profit;
+  accumulator.eventStats.set(eventKey, event);
   const month = Number.isFinite(timestamp) && timestamp !== Number.POSITIVE_INFINITY ? new Date(timestamp).toISOString().slice(0, 7) : "UNKNOWN";
   accumulator.monthProfits.set(
     month,
@@ -461,6 +609,15 @@ var emptyAiPocketSummary = ({
 }) => ({
   support: 0,
   supportRatio,
+  events: 0,
+  eventBalancedProfit: 0,
+  tradesPerEvent: null,
+  p95Batch: 0,
+  maxBatch: 0,
+  topEventCountShare: null,
+  topEventProfitShare: null,
+  topSymbolCountShare: null,
+  topSymbolProfitShare: null,
   totalProfit: 0,
   grossProfit: 0,
   grossLoss: 0,
@@ -532,9 +689,42 @@ var finalizeAiPocketSummary = ({
   const worstMonth = [...accumulator.monthProfits.entries()].sort(
     (left, right) => left[1] - right[1]
   )[0] ?? null;
+  const eventStats = [...accumulator.eventStats.values()];
+  const events = eventStats.length;
+  const batchSizes = eventStats.map((event) => event.count).sort((left, right) => left - right);
+  const p95Batch = batchSizes[Math.max(0, Math.ceil(batchSizes.length * 0.95) - 1)] ?? 0;
+  const maxBatch = batchSizes.at(-1) ?? 0;
+  const absoluteEventProfit = eventStats.reduce(
+    (sum, event) => sum + Math.abs(event.totalProfit),
+    0
+  );
+  const absoluteSymbolProfit = [...accumulator.symbolCounts.values()].reduce(
+    (sum, symbol) => sum + Math.abs(symbol.totalProfit),
+    0
+  );
   return {
     support,
     supportRatio,
+    events,
+    eventBalancedProfit: eventStats.reduce(
+      (sum, event) => sum + event.totalProfit / event.count,
+      0
+    ),
+    tradesPerEvent: events > 0 ? support / events : null,
+    p95Batch,
+    maxBatch,
+    topEventCountShare: support > 0 ? maxBatch / support : null,
+    topEventProfitShare: absoluteEventProfit > 0 ? Math.max(...eventStats.map((event) => Math.abs(event.totalProfit))) / absoluteEventProfit : null,
+    topSymbolCountShare: support > 0 ? Math.max(
+      ...[...accumulator.symbolCounts.values()].map(
+        (symbol) => symbol.count
+      )
+    ) / support : null,
+    topSymbolProfitShare: absoluteSymbolProfit > 0 ? Math.max(
+      ...[...accumulator.symbolCounts.values()].map(
+        (symbol) => Math.abs(symbol.totalProfit)
+      )
+    ) / absoluteSymbolProfit : null,
     totalProfit,
     grossProfit,
     grossLoss,
@@ -840,27 +1030,82 @@ var buildAiPocketPredicates = (rows, options = {}) => buildAiPocketPredicateResu
 var scorePositivePocket = (summary) => {
   const profitFactor = summary.profitFactor ?? (summary.grossLoss === 0 ? 8 : 0);
   const winRate = summary.winRate ?? 0;
-  return summary.totalProfit - summary.maxDrawdown * 0.6 + Math.min(profitFactor, 8) * 12 + winRate * 30 + Math.log10(summary.support + 1) * 6;
+  return summary.eventBalancedProfit - summary.maxDrawdown * 0.6 + Math.min(profitFactor, 8) * 12 + winRate * 30 + Math.log10(summary.events + 1) * 6;
 };
 var scoreNegativePocket = (summary) => -summary.totalProfit + summary.maxDrawdown * 0.4 + summary.grossLoss * 0.2 + summary.maxConsecutiveLosses * 3;
 var comparePositivePockets = (left, right) => (right.validationScore ?? right.score) - (left.validationScore ?? left.score) || right.score - left.score || (right.validationSummary?.totalProfit ?? right.summary.totalProfit) - (left.validationSummary?.totalProfit ?? left.summary.totalProfit) || right.summary.totalProfit - left.summary.totalProfit || (right.summary.profitFactor ?? 999) - (left.summary.profitFactor ?? 999) || right.summary.support - left.summary.support;
 var compareNegativePockets = (left, right) => (right.validationScore ?? right.score) - (left.validationScore ?? left.score) || right.score - left.score || (left.validationSummary?.totalProfit ?? left.summary.totalProfit) - (right.validationSummary?.totalProfit ?? right.summary.totalProfit) || left.summary.totalProfit - right.summary.totalProfit || right.summary.grossLoss - left.summary.grossLoss || right.summary.support - left.summary.support;
-var createPocketResult = (rows, predicates, mask, validationRows) => {
+var mergeDistinctRows = (left, right) => {
+  const seenRows = /* @__PURE__ */ new Set();
+  const seenSignalIds = /* @__PURE__ */ new Set();
+  return [...left, ...right].filter((row) => {
+    if (seenRows.has(row)) {
+      return false;
+    }
+    seenRows.add(row);
+    const signalId = typeof row.signalId === "string" && row.signalId.trim() ? row.signalId : null;
+    if (signalId == null) {
+      return true;
+    }
+    if (seenSignalIds.has(signalId)) {
+      return false;
+    }
+    seenSignalIds.add(signalId);
+    return true;
+  });
+};
+var resolveObjectiveRows = ({
+  objective,
+  selectedRows,
+  baselineRows
+}) => objective === "add-to-gate" ? mergeDistinctRows(baselineRows, selectedRows) : selectedRows;
+var effectiveProfitFactor = (summary) => summary.profitFactor ?? (summary.grossLoss === 0 && summary.totalProfit >= 0 ? Number.POSITIVE_INFINITY : 0);
+var doesNotRegressRisk = (candidate, baseline) => candidate.totalProfit >= baseline.totalProfit - 1e-9 && effectiveProfitFactor(candidate) >= effectiveProfitFactor(baseline) && candidate.maxDrawdown <= baseline.maxDrawdown + 1e-9 && candidate.maxConsecutiveLosses <= baseline.maxConsecutiveLosses && candidate.losingMonths <= baseline.losingMonths;
+var createPocketResult = (rows, predicates, mask, validationRows, testRows, objective, baselineRows, validationBaselineRows, testBaselineRows, objectiveBaseline, validationObjectiveBaseline, testObjectiveBaseline) => {
   const publicPredicates = predicates.map(toPublicPredicate);
   const summary = summarizeMask(rows, mask);
+  const selectedRows = rows.filter((_, index) => mask[index] === 1);
+  const objectiveRows = resolveObjectiveRows({
+    objective,
+    selectedRows,
+    baselineRows
+  });
+  const objectiveSummary = objective === "add-to-gate" ? summarizeAiPocketRows(objectiveRows) : summary;
   const validationMask = validationRows.length ? buildPredicateListMask(validationRows, publicPredicates).mask : null;
   const validationSummary = validationMask == null ? void 0 : summarizeMask(validationRows, validationMask);
+  const validationSelectedRows = validationMask == null ? [] : validationRows.filter((_, index) => validationMask[index] === 1);
+  const validationObjectiveRows = resolveObjectiveRows({
+    objective,
+    selectedRows: validationSelectedRows,
+    baselineRows: validationBaselineRows
+  });
+  const validationObjectiveSummary = validationRows.length ? objective === "add-to-gate" ? summarizeAiPocketRows(validationObjectiveRows) : validationSummary : void 0;
+  const testMask = testRows.length ? buildPredicateListMask(testRows, publicPredicates).mask : null;
+  const testSummary = testMask == null ? void 0 : summarizeMask(testRows, testMask);
+  const testSelectedRows = testMask == null ? [] : testRows.filter((_, index) => testMask[index] === 1);
+  const testObjectiveRows = resolveObjectiveRows({
+    objective,
+    selectedRows: testSelectedRows,
+    baselineRows: testBaselineRows
+  });
+  const testObjectiveSummary = testRows.length ? objective === "add-to-gate" ? summarizeAiPocketRows(testObjectiveRows) : testSummary : void 0;
   const condition = publicPredicates.map((predicate) => predicate.label).join(" AND ");
-  const validationScore = validationSummary == null ? void 0 : validationSummary.support > 0 ? scorePositivePocket(validationSummary) : Number.NEGATIVE_INFINITY;
+  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;
   return {
     id: publicPredicates.map((predicate) => predicate.id).join("&&"),
     depth: publicPredicates.length,
     predicates: publicPredicates,
     condition,
     summary,
+    ...objective === "standalone" ? {} : { objectiveSummary },
     ...validationSummary ? { validationSummary } : {},
+    ...testSummary ? { testSummary } : {},
+    ...objective !== "standalone" && validationObjectiveSummary ? { validationObjectiveSummary } : {},
+    ...objective !== "standalone" && testObjectiveSummary ? { testObjectiveSummary } : {},
     ...validationScore != null ? { validationScore } : {},
-    score: scorePositivePocket(summary)
+    ...testScore != null ? { testScore } : {},
+    score: scorePositivePocket(objectiveSummary) - (objective === "standalone" ? 0 : scorePositivePocket(objectiveBaseline))
   };
 };
 var hashMask = (mask) => {
@@ -891,6 +1136,83 @@ var estimateCombinationCount = (poolSize, maxDepth, maxCombinations) => {
   }
   return Math.min(Math.trunc(total), maxCombinations);
 };
+var classifyFeatureFamily = (featureKey) => {
+  const key = featureKey.toLowerCase();
+  if (/(setup|liquidity|doubletap|trendline|pivot|swing|zone)/.test(key)) {
+    return "strategy-structure";
+  }
+  if (/(structure|breakout|rejection|range|level)/.test(key)) {
+    return "market-structure";
+  }
+  if (/(participation|volume|turnover|obv|effort)/.test(key)) {
+    return "participation";
+  }
+  if (/(relative|benchmark|cmc|breadth|targetvs|btc|eth)/.test(key)) {
+    return "relative-market";
+  }
+  if (/(derivative|funding|openinterest|liquidation|longshort)/.test(key)) {
+    return "derivatives";
+  }
+  if (/(risk|stop|takeprofit|execution|spread|slippage)/.test(key)) {
+    return "execution-risk";
+  }
+  if (/(regime|momentum|trend|volatility|atr|macd|rsi|ma)/.test(key)) {
+    return "regime-indicators";
+  }
+  return "other";
+};
+var diversifyPredicatePool = (predicates, maximum) => {
+  const byFamily = /* @__PURE__ */ new Map();
+  const featureCounts = /* @__PURE__ */ new Map();
+  for (const predicate of predicates) {
+    const family = classifyFeatureFamily(predicate.featureKey);
+    const familyPredicates = byFamily.get(family) ?? [];
+    familyPredicates.push(predicate);
+    byFamily.set(family, familyPredicates);
+  }
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  while (selected.length < maximum) {
+    let added = false;
+    for (const familyPredicates of byFamily.values()) {
+      while (familyPredicates.length) {
+        const predicate = familyPredicates.shift();
+        if (selectedIds.has(predicate.id) || (featureCounts.get(predicate.featureKey) ?? 0) >= 4) {
+          continue;
+        }
+        selected.push(predicate);
+        selectedIds.add(predicate.id);
+        featureCounts.set(
+          predicate.featureKey,
+          (featureCounts.get(predicate.featureKey) ?? 0) + 1
+        );
+        added = true;
+        break;
+      }
+      if (selected.length >= maximum) {
+        break;
+      }
+    }
+    if (!added) {
+      break;
+    }
+  }
+  return selected;
+};
+var canCombinePredicate = (chosen, candidate) => {
+  const sameFeature = chosen.filter(
+    (predicate) => predicate.featureKey === candidate.featureKey
+  );
+  if (!sameFeature.length) {
+    return true;
+  }
+  if (sameFeature.length !== 1 || sameFeature[0].kind !== "numeric" || candidate.kind !== "numeric" || sameFeature[0].op === candidate.op) {
+    return false;
+  }
+  const lower = candidate.op === ">=" ? candidate.threshold : sameFeature[0].threshold;
+  const upper = candidate.op === "<=" ? candidate.threshold : sameFeature[0].threshold;
+  return lower <= upper;
+};
 var searchAiPockets = (rows, options = {}) => {
   const minSupport = Math.max(1, Math.trunc(options.minSupport ?? 20));
   const minProfitFactor = Math.max(0, options.minProfitFactor ?? 1.2);
@@ -907,10 +1229,36 @@ var searchAiPockets = (rows, options = {}) => {
   );
   const top = Math.max(1, Math.trunc(options.top ?? 50));
   const validationRows = options.validationRows ?? [];
+  const testRows = options.testRows ?? [];
   const minValidationSupport = Math.max(
     0,
     Math.trunc(options.minValidationSupport ?? 0)
   );
+  const minEvents = Math.max(1, Math.trunc(options.minEvents ?? 1));
+  const minValidationEvents = Math.max(
+    0,
+    Math.trunc(options.minValidationEvents ?? 0)
+  );
+  const maxBatch = Math.max(1, options.maxBatch ?? Number.POSITIVE_INFINITY);
+  const maxEventCountShare = Math.max(
+    0,
+    Math.min(1, options.maxEventCountShare ?? 1)
+  );
+  const maxSymbolCountShare = Math.max(
+    0,
+    Math.min(1, options.maxSymbolCountShare ?? 1)
+  );
+  const objective = options.objective ?? "standalone";
+  const baselineRows = options.baselineRows ?? (objective === "filter-gate" ? rows : []);
+  const validationBaselineRows = options.validationBaselineRows ?? (objective === "filter-gate" ? validationRows : []);
+  const testBaselineRows = options.testBaselineRows ?? (objective === "filter-gate" ? testRows : []);
+  const objectiveBaseline = summarizeAiPocketRows(baselineRows);
+  const validationObjectiveBaseline = summarizeAiPocketRows(
+    validationBaselineRows
+  );
+  const testObjectiveBaseline = summarizeAiPocketRows(testBaselineRows);
+  const allowRiskRegression = options.allowRiskRegression === true;
+  const requireValidationEligibility = options.requireValidationEligibility === true;
   const dedupeEquivalentSelections = options.dedupeEquivalentSelections !== false;
   const progressInterval = Math.max(
     1,
@@ -953,11 +1301,13 @@ var searchAiPockets = (rows, options = {}) => {
   const supportPool = [...scoredPredicates].sort((left, right) => right.support - left.support).slice(0, Math.ceil(maxAtomicPredicates * 0.2));
   const predicatePoolById = /* @__PURE__ */ new Map();
   [...predicatePool, ...negativePool, ...supportPool].forEach((predicate) => {
-    if (predicatePoolById.size < maxAtomicPredicates) {
-      predicatePoolById.set(predicate.id, predicate);
-    }
+    predicatePoolById.set(predicate.id, predicate);
   });
-  const selectedPredicatePool = [...predicatePoolById.values()].map(
+  const diversifiedPredicates = diversifyPredicatePool(
+    [...predicatePoolById.values()],
+    maxAtomicPredicates
+  );
+  const selectedPredicatePool = diversifiedPredicates.map(
     (predicate) => {
       const { mask, support } = buildMask(rows, predicate);
       return {
@@ -1001,14 +1351,30 @@ var searchAiPockets = (rows, options = {}) => {
       rows,
       pocketPredicates,
       mask,
-      validationRows
+      validationRows,
+      testRows,
+      objective,
+      baselineRows,
+      validationBaselineRows,
+      testBaselineRows,
+      objectiveBaseline,
+      validationObjectiveBaseline,
+      testObjectiveBaseline
     );
     const { summary } = pocket;
-    const profitFactor = summary.profitFactor ?? (summary.grossLoss === 0 && summary.totalProfit > 0 ? Number.POSITIVE_INFINITY : 0);
-    const winRate = summary.winRate ?? 0;
+    const scoredSummary = pocket.objectiveSummary ?? summary;
+    const profitFactor = scoredSummary.profitFactor ?? (scoredSummary.grossLoss === 0 && scoredSummary.totalProfit > 0 ? Number.POSITIVE_INFINITY : 0);
+    const winRate = scoredSummary.winRate ?? 0;
     const validationSupport = pocket.validationSummary?.support ?? 0;
-    const validationEligible = !validationRows.length || validationSupport >= minValidationSupport;
-    if (summary.support >= minSupport && summary.totalProfit >= minTotalProfit && profitFactor >= minProfitFactor && winRate >= minWinRate && validationEligible) {
+    const validationEligible = !validationRows.length || validationSupport >= minValidationSupport && (pocket.validationSummary?.events ?? 0) >= minValidationEvents && (pocket.validationSummary?.maxBatch ?? 0) <= maxBatch && (pocket.validationSummary?.topEventCountShare ?? 0) <= maxEventCountShare && (pocket.validationSummary?.topSymbolCountShare ?? 0) <= maxSymbolCountShare && (!requireValidationEligibility || (pocket.validationObjectiveSummary ?? pocket.validationSummary).totalProfit >= minTotalProfit && effectiveProfitFactor(
+      pocket.validationObjectiveSummary ?? pocket.validationSummary
+    ) >= minProfitFactor && ((pocket.validationObjectiveSummary ?? pocket.validationSummary).winRate ?? 0) >= minWinRate);
+    const concentrationEligible = summary.events >= minEvents && summary.maxBatch <= maxBatch && (summary.topEventCountShare ?? 0) <= maxEventCountShare && (summary.topSymbolCountShare ?? 0) <= maxSymbolCountShare;
+    const riskEligible = objective === "standalone" || allowRiskRegression || (!objectiveBaseline.support || doesNotRegressRisk(scoredSummary, objectiveBaseline)) && (!validationRows.length || !validationObjectiveBaseline.support || doesNotRegressRisk(
+      pocket.validationObjectiveSummary ?? pocket.validationSummary,
+      validationObjectiveBaseline
+    ));
+    if (summary.support >= minSupport && scoredSummary.totalProfit >= minTotalProfit && profitFactor >= minProfitFactor && winRate >= minWinRate && validationEligible && concentrationEligible && riskEligible) {
       const selectionKey = `${summary.support}:${hashMask(mask)}`;
       const mapKey = dedupeEquivalentSelections ? selectionKey : pocket.id;
       const existing = dedupeEquivalentSelections ? positiveSelectionKeys.get(mapKey) : positivePockets.get(mapKey);
@@ -1045,8 +1411,7 @@ var searchAiPockets = (rows, options = {}) => {
   const visit = ({
     startIndex,
     chosen,
-    mask,
-    usedFeatureKeys
+    mask
   }) => {
     if (truncated) {
       return;
@@ -1057,7 +1422,7 @@ var searchAiPockets = (rows, options = {}) => {
         return;
       }
       const predicate = selectedPredicatePool[index];
-      if (usedFeatureKeys.has(predicate.featureKey)) {
+      if (!canCombinePredicate(chosen, predicate)) {
         continue;
       }
       const intersection = mask == null ? { mask: predicate.mask, support: predicate.support } : intersectMasks(mask, predicate.mask);
@@ -1073,26 +1438,27 @@ var searchAiPockets = (rows, options = {}) => {
       if (nextChosen.length >= maxDepth) {
         continue;
       }
-      const nextUsedFeatureKeys = new Set(usedFeatureKeys);
-      nextUsedFeatureKeys.add(predicate.featureKey);
       visit({
         startIndex: index + 1,
         chosen: nextChosen,
-        mask: nextMask,
-        usedFeatureKeys: nextUsedFeatureKeys
+        mask: nextMask
       });
     }
   };
   visit({
     startIndex: 0,
     chosen: [],
-    mask: null,
-    usedFeatureKeys: /* @__PURE__ */ new Set()
+    mask: null
   });
   emitProgress(true);
   return {
+    objective,
     baseline: summarizeAiPocketRows(rows),
     ...validationRows.length ? { validationBaseline: summarizeAiPocketRows(validationRows) } : {},
+    ...testRows.length ? { testBaseline: summarizeAiPocketRows(testRows) } : {},
+    ...objective === "standalone" ? {} : { objectiveBaseline },
+    ...objective !== "standalone" && validationRows.length ? { validationObjectiveBaseline } : {},
+    ...objective !== "standalone" && testRows.length ? { testObjectiveBaseline } : {},
     predicates: predicates.map(toPublicPredicate),
     positivePockets: [...positivePockets.values()].sort(comparePositivePockets).slice(0, top),
     negativePockets: [...negativePockets.values()].sort(compareNegativePockets).slice(0, top),
@@ -1104,7 +1470,15 @@ var searchAiPockets = (rows, options = {}) => {
       estimatedCombinations,
       combinationsEvaluated,
       validationRows: validationRows.length,
+      testRows: testRows.length,
       duplicatePocketsSkipped,
+      featureFamiliesUsed: [
+        ...new Set(
+          selectedPredicatePool.map(
+            (predicate) => classifyFeatureFamily(predicate.featureKey)
+          )
+        )
+      ],
       truncated
     }
   };
@@ -1122,6 +1496,13 @@ var markdownTable = (headers, rows) => {
 };
 var summaryMetricRows = (summary) => [
   ["rows", summary.support],
+  ["events", summary.events],
+  ["event_balanced_profit", formatMdNumber(summary.eventBalancedProfit)],
+  ["trades_per_event", formatMdNumber(summary.tradesPerEvent)],
+  ["p95_batch", summary.p95Batch],
+  ["max_batch", summary.maxBatch],
+  ["top_event_count_share", formatMdPercent(summary.topEventCountShare)],
+  ["top_symbol_count_share", formatMdPercent(summary.topSymbolCountShare)],
   ["win_rate", formatMdPercent(summary.winRate)],
   ["total_profit", formatMdNumber(summary.totalProfit)],
   ["gross_profit", formatMdNumber(summary.grossProfit)],
@@ -1150,15 +1531,22 @@ var summaryMetricRows = (summary) => [
 var pocketRows = (pockets) => pockets.map((pocket, index) => [
   index + 1,
   pocket.summary.support,
+  pocket.summary.events,
+  pocket.summary.maxBatch,
   formatMdPercent(pocket.summary.supportRatio),
   formatMdPercent(pocket.summary.winRate),
   formatMdNumber(pocket.summary.profitFactor),
   formatMdNumber(pocket.summary.totalProfit),
+  pocket.objectiveSummary ? formatMdNumber(pocket.objectiveSummary.totalProfit) : "n/a",
   formatMdNumber(pocket.summary.maxDrawdown),
   pocket.validationSummary?.support ?? "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 ? 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),
@@ -1172,6 +1560,13 @@ var buildAiPocketMarkdownReport = ({
   errors
 }) => {
   const generatedIso = new Date(generatedAt).toISOString();
+  const featurePolicyAuditRows = Object.entries(
+    run.featurePolicyAudit ?? {}
+  ).map(([classification, audit]) => [
+    classification,
+    audit?.paths ?? 0,
+    audit?.samples.join(", ") ?? ""
+  ]);
   const lines = [
     "# AI Pocket Search Report",
     "",
@@ -1187,6 +1582,7 @@ var buildAiPocketMarkdownReport = ({
         ["selected_rows", run.selectedRows],
         ["evaluated_rows", run.evaluatedRows],
         ["scope", run.scope],
+        ["objective", run.objective ?? pocketSearch.objective],
         ["direction", run.direction ?? "all"],
         ["scope_rows", run.scopeRows],
         ["train_rows", run.trainRows],
@@ -1210,15 +1606,44 @@ var buildAiPocketMarkdownReport = ({
         ["min_quality", run.minQuality],
         ["max_depth", run.search.maxDepth],
         ["min_support", run.search.minSupport],
+        ["min_events", run.search.minEvents ?? 1],
+        ["min_validation_events", run.search.minValidationEvents ?? 0],
+        ["max_batch", run.search.maxBatch ?? "off"],
+        [
+          "max_event_count_share",
+          run.search.maxEventCountShare == null ? "off" : formatMdPercent(run.search.maxEventCountShare)
+        ],
+        [
+          "max_symbol_count_share",
+          run.search.maxSymbolCountShare == null ? "off" : formatMdPercent(run.search.maxSymbolCountShare)
+        ],
+        [
+          "allow_risk_regression",
+          run.search.allowRiskRegression ? "yes" : "no"
+        ],
+        [
+          "require_validation_eligibility",
+          run.search.requireValidationEligibility ? "yes" : "no"
+        ],
         ["max_atomic_predicates", run.search.maxAtomicPredicates],
         ["max_combinations", run.search.maxCombinations],
         ["include_symbol", run.includeSymbol ? "on" : "off"],
         ["include_gate_context", run.includeGateContext ? "on" : "off"],
         ["feature_profile", run.featureProfile ?? "all"],
+        ["feature_policy", run.featurePolicy ?? "all"],
         ["report_path", run.reportPath]
       ]
     ),
     "",
+    ...featurePolicyAuditRows.length ? [
+      "## Feature Policy Audit",
+      "",
+      markdownTable(
+        ["Classification", "Excluded paths", "Samples"],
+        featurePolicyAuditRows
+      ),
+      ""
+    ] : [],
     "## Dataset Files",
     "",
     ...run.filePaths.map((filePath) => `- \`${filePath}\``),
@@ -1255,6 +1680,33 @@ var buildAiPocketMarkdownReport = ({
       ),
       ""
     ] : [],
+    ...pocketSearch.testBaseline ? [
+      "## Untouched Test Baseline",
+      "",
+      markdownTable(
+        ["Metric", "Value"],
+        summaryMetricRows(pocketSearch.testBaseline)
+      ),
+      ""
+    ] : [],
+    ...pocketSearch.objectiveBaseline ? [
+      "## Current Gate Train Baseline",
+      "",
+      markdownTable(
+        ["Metric", "Value"],
+        summaryMetricRows(pocketSearch.objectiveBaseline)
+      ),
+      ""
+    ] : [],
+    ...pocketSearch.testObjectiveBaseline ? [
+      "## Current Gate Untouched Test Baseline",
+      "",
+      markdownTable(
+        ["Metric", "Value"],
+        summaryMetricRows(pocketSearch.testObjectiveBaseline)
+      ),
+      ""
+    ] : [],
     "## Search Stats",
     "",
     markdownTable(
@@ -1263,9 +1715,11 @@ var buildAiPocketMarkdownReport = ({
         ["feature_keys", pocketSearch.stats.featureKeys],
         ["predicates", pocketSearch.stats.predicates],
         ["atomic_used", pocketSearch.stats.atomicPredicatesUsed],
+        ["feature_families", pocketSearch.stats.featureFamiliesUsed.join(", ")],
         ["estimated_combinations", pocketSearch.stats.estimatedCombinations],
         ["combinations_evaluated", pocketSearch.stats.combinationsEvaluated],
         ["validation_rows", pocketSearch.stats.validationRows],
+        ["test_rows", pocketSearch.stats.testRows],
         [
           "duplicate_pockets_skipped",
           pocketSearch.stats.duplicatePocketsSkipped
@@ -1280,15 +1734,22 @@ var buildAiPocketMarkdownReport = ({
       [
         "#",
         "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",
@@ -1303,15 +1764,22 @@ var buildAiPocketMarkdownReport = ({
       [
         "#",
         "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",
@@ -1331,6 +1799,7 @@ var buildAiPocketMarkdownReport = ({
 0 && (module.exports = {
   buildAiPocketMarkdownReport,
   buildAiPocketPredicates,
+  classifyAiPocketFeaturePath,
   collectAiPocketFeatures,
   searchAiPockets,
   summarizeAiPocketRows