@tradejs/cli 2.0.15 → 2.0.16

package/dist/scripts/aiPocketSearch.js

@@ -2078,6 +2078,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 = (path2) => {
+  const segments = (Array.isArray(path2) ? path2 : path2.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) {
@@ -2339,7 +2448,9 @@ var collectAiPocketFeatures = ({
   gateContext,
   includeSymbol = false,
   includeGateContext = false,
-  featureProfile = "all"
+  featureProfile = "all",
+  featurePolicy = "all",
+  onFeatureExcluded
 }) => {
   const features = {};
   const signal = payload.signal ?? {};
@@ -2359,8 +2470,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;
@@ -2413,6 +2551,7 @@ var createSummaryAccumulator = () => ({
   directionCounts: /* @__PURE__ */ new Map(),
   symbolCounts: /* @__PURE__ */ new Map(),
   monthProfits: /* @__PURE__ */ new Map(),
+  eventStats: /* @__PURE__ */ new Map(),
   equityPoints: []
 });
 var addSummaryRow = (accumulator, row) => {
@@ -2438,6 +2577,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,
@@ -2451,6 +2598,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,
@@ -2522,9 +2678,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,
@@ -2829,27 +3018,82 @@ var buildAiPocketPredicateResult = (rows, options = {}) => {
 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) => {
@@ -2880,6 +3124,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);
@@ -2896,10 +3217,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,
@@ -2942,11 +3289,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 {
@@ -2990,14 +3339,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);
@@ -3034,8 +3399,7 @@ var searchAiPockets = (rows, options = {}) => {
   const visit = ({
     startIndex,
     chosen,
-    mask,
-    usedFeatureKeys
+    mask
   }) => {
     if (truncated) {
       return;
@@ -3046,7 +3410,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);
@@ -3062,26 +3426,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),
@@ -3093,7 +3458,15 @@ var searchAiPockets = (rows, options = {}) => {
       estimatedCombinations,
       combinationsEvaluated,
       validationRows: validationRows.length,
+      testRows: testRows.length,
       duplicatePocketsSkipped,
+      featureFamiliesUsed: [
+        ...new Set(
+          selectedPredicatePool.map(
+            (predicate) => classifyFeatureFamily(predicate.featureKey)
+          )
+        )
+      ],
       truncated
     }
   };
@@ -3111,6 +3484,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)],
@@ -3139,15 +3519,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),
@@ -3161,6 +3548,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",
     "",
@@ -3176,6 +3570,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],
@@ -3199,15 +3594,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}\``),
@@ -3244,6 +3668,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(
@@ -3252,9 +3703,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
@@ -3269,15 +3722,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",
@@ -3292,15 +3752,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",
@@ -3478,6 +3945,46 @@ import_args.default.option(
   "Minimum validation rows required for positive pockets (0 = auto)",
   0
 );
+import_args.default.option(
+  ["H", "minEvents"],
+  "Minimum independent timestamp events required (0 = auto)",
+  0
+);
+import_args.default.option(
+  ["J", "minValidationEvents"],
+  "Minimum validation timestamp events required (0 = auto)",
+  0
+);
+import_args.default.option(
+  ["X", "maxBatch"],
+  "Maximum selected rows at one timestamp (0 disables)",
+  5
+);
+import_args.default.option(
+  ["U", "maxEventCountShare"],
+  "Maximum row share contributed by one timestamp event",
+  "0.25"
+);
+import_args.default.option(
+  ["Z", "maxSymbolCountShare"],
+  "Maximum row share contributed by one symbol",
+  "0.5"
+);
+import_args.default.option(
+  ["A", "objective"],
+  "Search objective: auto, standalone, add-to-gate, or filter-gate",
+  "auto"
+);
+import_args.default.option(
+  ["G", "allowRiskRegression"],
+  "Allow incremental pockets to worsen q4+ PF, PnL, drawdown, or loss streak",
+  false
+);
+import_args.default.option(
+  ["L", "allowValidationRegression"],
+  "Keep train-positive pockets that fail validation PnL/PF thresholds",
+  false
+);
 import_args.default.option(
   ["D", "dedupeEquivalentSelections"],
   "Collapse pockets that select the same train rows",
@@ -3495,6 +4002,11 @@ import_args.default.option(
   "Feature extraction profile: compact or all",
   "all"
 );
+import_args.default.option(
+  ["K", "featurePolicy"],
+  "Feature policy: causal-stationary or all",
+  "causal-stationary"
+);
 import_args.default.option(
   ["r", "reportDir"],
   "Directory for generated Markdown reports",
@@ -3599,10 +4111,41 @@ var normalizeRatio = (value, fallback) => {
   }
   return Math.max(0, Math.min(0.9, parsed));
 };
+var normalizeUnitRatio = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : fallback;
+};
 var normalizeFeatureProfile = (value) => {
   const normalized = String(value || "all").trim().toLowerCase();
   return normalized === "compact" ? "compact" : "all";
 };
+var normalizeFeaturePolicy = (value) => {
+  const normalized = String(value || "causal-stationary").trim().toLowerCase();
+  if (!["causal-stationary", "all"].includes(normalized)) {
+    throw new Error(
+      `Unsupported --featurePolicy "${normalized}". Use causal-stationary or all.`
+    );
+  }
+  return normalized;
+};
+var normalizeObjective = (value, scope) => {
+  const normalized = String(value || "auto").trim().toLowerCase();
+  if (normalized === "auto") {
+    if (scope === "approved") {
+      return "filter-gate";
+    }
+    if (scope === "rejected" || scope === "candidates") {
+      return "add-to-gate";
+    }
+    return "standalone";
+  }
+  if (!["standalone", "add-to-gate", "filter-gate"].includes(normalized)) {
+    throw new Error(
+      `Unsupported --objective "${normalized}". Use auto, standalone, add-to-gate, or filter-gate.`
+    );
+  }
+  return normalized;
+};
 var normalizeQuality = (analysis) => {
   const quality = Number(analysis?.quality);
   return Number.isFinite(quality) ? Math.round(quality) : null;
@@ -3757,7 +4300,7 @@ var resolveScopeRows = (rows, scope) => {
     return rows.filter((row) => !row.aiApproved);
   }
   if (scope === "candidates") {
-    return rows.filter((row) => row.modelCandidate);
+    return rows.filter((row) => row.modelCandidate && !row.aiApproved);
   }
   return rows;
 };
@@ -3768,6 +4311,13 @@ var printSection = (title, table) => {
 };
 var buildSummaryRows = (summary) => [
   ["rows", import_chalk.default.cyan(String(summary.support))],
+  ["events", import_chalk.default.cyan(String(summary.events))],
+  ["event_balanced_profit", colorizeProfit(summary.eventBalancedProfit)],
+  ["trades_per_event", colorizeNumber(summary.tradesPerEvent)],
+  ["p95_batch", import_chalk.default.cyan(String(summary.p95Batch))],
+  ["max_batch", import_chalk.default.cyan(String(summary.maxBatch))],
+  ["top_event_count_share", colorizeRatio(summary.topEventCountShare)],
+  ["top_symbol_count_share", colorizeRatio(summary.topSymbolCountShare)],
   ["win_rate", colorizeRatio(summary.winRate)],
   ["total_profit", colorizeProfit(summary.totalProfit)],
   ["gross_profit", colorizeProfit(summary.grossProfit)],
@@ -3796,15 +4346,22 @@ var buildSummaryRows = (summary) => [
 var buildPocketRows = (pockets) => pockets.map((pocket, index) => [
   import_chalk.default.gray(String(index + 1)),
   import_chalk.default.cyan(String(pocket.summary.support)),
+  import_chalk.default.cyan(String(pocket.summary.events)),
+  import_chalk.default.cyan(String(pocket.summary.maxBatch)),
   colorizeRatio(pocket.summary.supportRatio),
   colorizeRatio(pocket.summary.winRate),
   colorizeNumber(pocket.summary.profitFactor),
   colorizeProfit(pocket.summary.totalProfit),
+  pocket.objectiveSummary ? colorizeProfit(pocket.objectiveSummary.totalProfit) : import_chalk.default.gray("n/a"),
   colorizeProfit(-pocket.summary.maxDrawdown),
   pocket.validationSummary ? import_chalk.default.cyan(String(pocket.validationSummary.support)) : import_chalk.default.gray("n/a"),
   pocket.validationSummary ? colorizeRatio(pocket.validationSummary.winRate) : import_chalk.default.gray("n/a"),
   pocket.validationSummary ? colorizeNumber(pocket.validationSummary.profitFactor) : import_chalk.default.gray("n/a"),
   pocket.validationSummary ? colorizeProfit(pocket.validationSummary.totalProfit) : import_chalk.default.gray("n/a"),
+  pocket.testSummary ? import_chalk.default.cyan(String(pocket.testSummary.support)) : import_chalk.default.gray("n/a"),
+  pocket.testSummary ? colorizeNumber(pocket.testSummary.profitFactor) : import_chalk.default.gray("n/a"),
+  pocket.testSummary ? colorizeProfit(pocket.testSummary.totalProfit) : import_chalk.default.gray("n/a"),
+  pocket.testObjectiveSummary ? colorizeProfit(pocket.testObjectiveSummary.totalProfit) : import_chalk.default.gray("n/a"),
   colorizeNumber(pocket.summary.avgTradesPerDay),
   import_chalk.default.yellow(String(pocket.summary.losingMonths)),
   colorizeNumber(pocket.score),
@@ -3915,16 +4472,45 @@ var main = async () => {
     flags.minValidationSupport,
     0
   );
+  const explicitMinEvents = normalizeInt(flags.minEvents, 0);
+  const explicitMinValidationEvents = normalizeInt(
+    flags.minValidationEvents,
+    0
+  );
+  const maxBatch = normalizeInt(flags.maxBatch, 5);
+  const maxEventCountShare = normalizeUnitRatio(
+    readAiPocketSearchCliOption({
+      argv: process.argv,
+      longName: "maxEventCountShare",
+      shortName: "U"
+    }) ?? flags.maxEventCountShare,
+    0.25
+  );
+  const maxSymbolCountShare = normalizeUnitRatio(
+    readAiPocketSearchCliOption({
+      argv: process.argv,
+      longName: "maxSymbolCountShare",
+      shortName: "Z"
+    }) ?? flags.maxSymbolCountShare,
+    0.5
+  );
+  const objective = normalizeObjective(flags.objective, scope);
+  const allowRiskRegression = Boolean(flags.allowRiskRegression);
+  const requireValidationEligibility = !Boolean(
+    flags.allowValidationRegression
+  );
   const dedupeEquivalentSelections = Boolean(flags.dedupeEquivalentSelections);
   const top = normalizePositiveInt(flags.top, 30);
   const includeSymbol = Boolean(flags.includeSymbol);
   const includeGateContext = Boolean(flags.includeGateContext);
   const featureProfile = normalizeFeatureProfile(flags.featureProfile);
+  const featurePolicy = normalizeFeaturePolicy(flags.featurePolicy);
   const jsonOutput = Boolean(flags.json);
   const outputPath = String(flags.output || "").trim();
   const reportDir = String(flags.reportDir || "data/ai/output").trim();
   const explicitReportFile = String(flags.reportFile || "").trim();
   const generatedAt = Date.now();
+  const excludedFeaturePaths = /* @__PURE__ */ new Map();
   await (0, import_ai2.ensureAiStrategyPluginsLoaded)();
   const filePaths = await resolveMergedDatasetFiles({
     outDir,
@@ -4029,7 +4615,13 @@ var main = async () => {
             gateContext,
             includeSymbol,
             includeGateContext,
-            featureProfile
+            featureProfile,
+            featurePolicy,
+            onFeatureExcluded: ({ path: featurePath, classification }) => {
+              const paths = excludedFeaturePaths.get(classification) ?? /* @__PURE__ */ new Set();
+              paths.add(featurePath);
+              excludedFeaturePaths.set(classification, paths);
+            }
           })
         });
         bar?.tick(1, {
@@ -4050,10 +4642,24 @@ var main = async () => {
       }
     }
   });
-  const scopedRows = resolveScopeRows(rows, scope);
-  const scopeRows = direction ? scopedRows.filter((row) => row.direction === direction) : scopedRows;
-  const { trainRows, validationRows, testRows } = splitAiPocketResearchRowsByTimestamp(scopeRows, validationSplit, testSplit);
+  const directionRows = direction ? rows.filter((row) => row.direction === direction) : rows;
+  const scopeRows = resolveScopeRows(directionRows, scope);
+  const split = splitAiPocketResearchRowsByTimestamp(
+    directionRows,
+    validationSplit,
+    testSplit
+  );
+  const trainRows = resolveScopeRows(split.trainRows, scope);
+  const validationRows = resolveScopeRows(split.validationRows, scope);
+  const testRows = resolveScopeRows(split.testRows, scope);
+  const baselineRows = split.trainRows.filter((row) => row.aiApproved);
+  const validationBaselineRows = split.validationRows.filter(
+    (row) => row.aiApproved
+  );
+  const testBaselineRows = split.testRows.filter((row) => row.aiApproved);
   const minValidationSupport = explicitMinValidationSupport > 0 ? explicitMinValidationSupport : validationRows.length ? Math.max(3, Math.ceil(minSupport * validationSplit * 0.5)) : 0;
+  const minEvents = explicitMinEvents > 0 ? explicitMinEvents : Math.max(5, Math.ceil(minSupport * 0.5));
+  const minValidationEvents = explicitMinValidationEvents > 0 ? explicitMinValidationEvents : validationRows.length ? Math.max(2, Math.ceil(minEvents * validationSplit * 0.5)) : 0;
   const currentGateSummary = summarizeAiTrainEvaluations(rows);
   const currentGateQualityThresholds = summarizeAiTrainEvaluationsByQualityThreshold(rows, qualityThresholds);
   let searchBar = null;
@@ -4068,7 +4674,19 @@ var main = async () => {
     maxCombinations,
     top,
     validationRows,
+    testRows,
     minValidationSupport,
+    minEvents,
+    minValidationEvents,
+    ...maxBatch > 0 ? { maxBatch } : {},
+    maxEventCountShare,
+    maxSymbolCountShare,
+    objective,
+    baselineRows,
+    validationBaselineRows,
+    testBaselineRows,
+    allowRiskRegression,
+    requireValidationEligibility,
     dedupeEquivalentSelections,
     progressInterval: 250,
     onProgress: (progress) => {
@@ -4133,6 +4751,17 @@ var main = async () => {
       includeSymbol,
       includeGateContext,
       featureProfile,
+      featurePolicy,
+      featurePolicyAudit: Object.fromEntries(
+        [...excludedFeaturePaths.entries()].map(([classification, paths]) => [
+          classification,
+          {
+            paths: paths.size,
+            samples: [...paths].sort().slice(0, 5)
+          }
+        ])
+      ),
+      objective,
       validationSplit,
       testSplit,
       minValidationSupport,
@@ -4145,6 +4774,13 @@ var main = async () => {
         minTotalProfit,
         maxAtomicPredicates,
         maxCombinations,
+        minEvents,
+        minValidationEvents,
+        ...maxBatch > 0 ? { maxBatch } : {},
+        maxEventCountShare,
+        maxSymbolCountShare,
+        allowRiskRegression,
+        requireValidationEligibility,
         validationSplit,
         testSplit,
         minValidationSupport,
@@ -4188,6 +4824,7 @@ var main = async () => {
         ["selected", import_chalk.default.blue(String(selectedRows))],
         ["evaluated", import_chalk.default.blue(String(rows.length))],
         ["scope", import_chalk.default.yellow(scope)],
+        ["objective", import_chalk.default.yellow(objective)],
         ["direction", direction ? import_chalk.default.yellow(direction) : import_chalk.default.gray("all")],
         ["scope_rows", import_chalk.default.blue(String(scopeRows.length))],
         ["train_rows", import_chalk.default.blue(String(trainRows.length))],
@@ -4216,6 +4853,11 @@ var main = async () => {
         ["min_quality", import_chalk.default.magenta(String(minQuality))],
         ["max_depth", import_chalk.default.magenta(String(maxDepth))],
         ["min_support", import_chalk.default.magenta(String(minSupport))],
+        ["min_events", import_chalk.default.magenta(String(minEvents))],
+        ["min_validation_events", import_chalk.default.magenta(String(minValidationEvents))],
+        ["max_batch", import_chalk.default.magenta(maxBatch > 0 ? String(maxBatch) : "off")],
+        ["max_event_share", import_chalk.default.magenta(formatRatio(maxEventCountShare))],
+        ["max_symbol_share", import_chalk.default.magenta(formatRatio(maxSymbolCountShare))],
         ["max_atomic_predicates", import_chalk.default.magenta(String(maxAtomicPredicates))],
         ["max_combinations", import_chalk.default.magenta(String(maxCombinations))],
         ["validation_split", import_chalk.default.magenta(formatRatio(validationSplit))],
@@ -4234,6 +4876,15 @@ var main = async () => {
           includeGateContext ? import_chalk.default.yellow("on") : import_chalk.default.gray("off")
         ],
         ["feature_profile", import_chalk.default.magenta(featureProfile)],
+        ["feature_policy", import_chalk.default.magenta(featurePolicy)],
+        [
+          "allow_risk_regression",
+          allowRiskRegression ? import_chalk.default.yellow("on") : import_chalk.default.green("off")
+        ],
+        [
+          "validation_eligibility",
+          requireValidationEligibility ? import_chalk.default.green("required") : import_chalk.default.yellow("off")
+        ],
         ["report", import_chalk.default.gray(reportPath)],
         ["output", outputPath ? import_chalk.default.gray(outputPath) : import_chalk.default.gray("off")]
       ]
@@ -4271,6 +4922,24 @@ var main = async () => {
       )
     );
   }
+  if (search.testBaseline) {
+    printSection(
+      "UNTOUCHED TEST BASELINE",
+      createTable(
+        [import_chalk.default.gray("METRIC"), import_chalk.default.gray("VALUE")],
+        buildSummaryRows(search.testBaseline)
+      )
+    );
+  }
+  if (search.objectiveBaseline) {
+    printSection(
+      "CURRENT GATE TRAIN BASELINE",
+      createTable(
+        [import_chalk.default.gray("METRIC"), import_chalk.default.gray("VALUE")],
+        buildSummaryRows(search.objectiveBaseline)
+      )
+    );
+  }
   printSection(
     "SEARCH STATS",
     createTable(
@@ -4279,6 +4948,10 @@ var main = async () => {
         ["feature_keys", import_chalk.default.cyan(String(search.stats.featureKeys))],
         ["predicates", import_chalk.default.cyan(String(search.stats.predicates))],
         ["atomic_used", import_chalk.default.cyan(String(search.stats.atomicPredicatesUsed))],
+        [
+          "feature_families",
+          import_chalk.default.cyan(search.stats.featureFamiliesUsed.join(", "))
+        ],
         [
           "estimated_combinations",
           import_chalk.default.cyan(String(search.stats.estimatedCombinations))
@@ -4288,6 +4961,7 @@ var main = async () => {
           import_chalk.default.cyan(String(search.stats.combinationsEvaluated))
         ],
         ["validation_rows", import_chalk.default.cyan(String(search.stats.validationRows))],
+        ["test_rows", import_chalk.default.cyan(String(search.stats.testRows))],
         [
           "duplicate_pockets_skipped",
           import_chalk.default.cyan(String(search.stats.duplicatePocketsSkipped))
@@ -4305,15 +4979,22 @@ var main = async () => {
       [
         import_chalk.default.gray("#"),
         import_chalk.default.gray("N"),
+        import_chalk.default.gray("EVENTS"),
+        import_chalk.default.gray("MAX_B"),
         import_chalk.default.gray("SUP"),
         import_chalk.default.gray("WR"),
         import_chalk.default.gray("PF"),
         import_chalk.default.gray("PNL"),
+        import_chalk.default.gray("OBJ_PNL"),
         import_chalk.default.gray("MAX_DD"),
         import_chalk.default.gray("VAL_N"),
         import_chalk.default.gray("VAL_WR"),
         import_chalk.default.gray("VAL_PF"),
         import_chalk.default.gray("VAL_PNL"),
+        import_chalk.default.gray("TEST_N"),
+        import_chalk.default.gray("TEST_PF"),
+        import_chalk.default.gray("TEST_PNL"),
+        import_chalk.default.gray("TEST_OBJ"),
         import_chalk.default.gray("TR/D"),
         import_chalk.default.gray("LOSS_M"),
         import_chalk.default.gray("SCORE"),
@@ -4328,15 +5009,22 @@ var main = async () => {
       [
         import_chalk.default.gray("#"),
         import_chalk.default.gray("N"),
+        import_chalk.default.gray("EVENTS"),
+        import_chalk.default.gray("MAX_B"),
         import_chalk.default.gray("SUP"),
         import_chalk.default.gray("WR"),
         import_chalk.default.gray("PF"),
         import_chalk.default.gray("PNL"),
+        import_chalk.default.gray("OBJ_PNL"),
         import_chalk.default.gray("MAX_DD"),
         import_chalk.default.gray("VAL_N"),
         import_chalk.default.gray("VAL_WR"),
         import_chalk.default.gray("VAL_PF"),
         import_chalk.default.gray("VAL_PNL"),
+        import_chalk.default.gray("TEST_N"),
+        import_chalk.default.gray("TEST_PF"),
+        import_chalk.default.gray("TEST_PNL"),
+        import_chalk.default.gray("TEST_OBJ"),
         import_chalk.default.gray("TR/D"),
         import_chalk.default.gray("LOSS_M"),
         import_chalk.default.gray("SCORE"),