@tradejs/cli 1.0.8 → 1.0.10

package/dist/scripts/aiTrain.js

@@ -8,6 +8,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -24,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/debug/node_modules/ms/index.js
 var require_ms = __commonJS({
@@ -1622,15 +1627,21 @@ var require_list_it = __commonJS({
 });
 
 // src/scripts/aiTrain.ts
+var aiTrain_exports = {};
+__export(aiTrain_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(aiTrain_exports);
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
-var import_promises = __toESM(require("fs/promises"));
+var import_promises2 = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
 var import_progress = __toESM(require("progress"));
-var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
 var import_ai = require("@tradejs/infra/ai");
+var import_redis = require("@tradejs/infra/redis");
 var import_ai2 = require("@tradejs/node/ai");
-var import_constants = require("@tradejs/node/constants");
+var import_constants2 = require("@tradejs/node/constants");
 
 // src/lib/aiTrainMetrics.ts
 var divideOrNull = (num, denom) => {
@@ -1643,17 +1654,119 @@ var DAY_MS = 24 * 60 * 60 * 1e3;
 var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
 var getEvaluationPeriodDays = (evaluations) => {
-  const timestamps = evaluations.map(
-    (evaluation) => typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp) ? evaluation.timestamp : null
-  ).filter((timestamp) => timestamp != null);
-  if (!timestamps.length) {
+  let minTimestamp = null;
+  let maxTimestamp = null;
+  for (const evaluation of evaluations) {
+    const timestamp = typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp) ? evaluation.timestamp : null;
+    if (timestamp == null) {
+      continue;
+    }
+    if (minTimestamp == null || timestamp < minTimestamp) {
+      minTimestamp = timestamp;
+    }
+    if (maxTimestamp == null || timestamp > maxTimestamp) {
+      maxTimestamp = timestamp;
+    }
+  }
+  if (minTimestamp == null || maxTimestamp == null) {
     return null;
   }
-  const minTimestamp = Math.min(...timestamps);
-  const maxTimestamp = Math.max(...timestamps);
   return Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1);
 };
 var qualitySortKey = (quality) => quality == null ? Number.POSITIVE_INFINITY : quality;
+var emptyRiskSummary = () => ({
+  trades: 0,
+  totalProfit: 0,
+  grossProfit: 0,
+  grossLoss: 0,
+  profitFactor: null,
+  payoffRatio: null,
+  avgWin: null,
+  avgLoss: null,
+  largestWin: null,
+  largestLoss: null,
+  winRate: null,
+  maxDrawdown: 0,
+  maxDrawdownPctOfGrossProfit: null,
+  maxDrawdownPctOfTotalProfit: null,
+  recoveryFactor: null,
+  ulcerIndex: null,
+  maxConsecutiveWins: 0,
+  maxConsecutiveLosses: 0
+});
+var summarizeApprovedRisk = (evaluations) => {
+  const approvedEvaluations = evaluations.filter((evaluation) => evaluation.aiApproved).sort((left, right) => {
+    const leftTimestamp = typeof left.timestamp === "number" && Number.isFinite(left.timestamp) ? left.timestamp : Number.POSITIVE_INFINITY;
+    const rightTimestamp = typeof right.timestamp === "number" && Number.isFinite(right.timestamp) ? right.timestamp : Number.POSITIVE_INFINITY;
+    return leftTimestamp - rightTimestamp;
+  });
+  if (!approvedEvaluations.length) {
+    return emptyRiskSummary();
+  }
+  let grossProfit = 0;
+  let grossLoss = 0;
+  let wins = 0;
+  let losses = 0;
+  let largestWin = null;
+  let largestLoss = null;
+  let equity = 0;
+  let peakEquity = 0;
+  let maxDrawdown = 0;
+  let drawdownSquares = 0;
+  let currentWinStreak = 0;
+  let currentLossStreak = 0;
+  let maxConsecutiveWins = 0;
+  let maxConsecutiveLosses = 0;
+  for (const evaluation of approvedEvaluations) {
+    const profit = evaluation.profit;
+    if (profit > 0) {
+      grossProfit += profit;
+      wins += 1;
+      largestWin = largestWin == null ? profit : Math.max(largestWin, profit);
+      currentWinStreak += 1;
+      currentLossStreak = 0;
+    } else if (profit < 0) {
+      grossLoss += Math.abs(profit);
+      losses += 1;
+      largestLoss = largestLoss == null ? profit : Math.min(largestLoss, profit);
+      currentLossStreak += 1;
+      currentWinStreak = 0;
+    } else {
+      currentWinStreak = 0;
+      currentLossStreak = 0;
+    }
+    maxConsecutiveWins = Math.max(maxConsecutiveWins, currentWinStreak);
+    maxConsecutiveLosses = Math.max(maxConsecutiveLosses, currentLossStreak);
+    equity += profit;
+    peakEquity = Math.max(peakEquity, equity);
+    const drawdown = Math.max(0, peakEquity - equity);
+    maxDrawdown = Math.max(maxDrawdown, drawdown);
+    drawdownSquares += drawdown * drawdown;
+  }
+  const totalProfit = grossProfit - grossLoss;
+  const avgWin = divideOrNull(grossProfit, wins);
+  const avgLoss = divideOrNull(grossLoss, losses);
+  return {
+    trades: approvedEvaluations.length,
+    totalProfit,
+    grossProfit,
+    grossLoss,
+    profitFactor: grossLoss > 0 ? grossProfit / grossLoss : null,
+    payoffRatio: avgWin != null && avgLoss != null && avgLoss > 0 ? avgWin / avgLoss : null,
+    avgWin,
+    avgLoss,
+    largestWin,
+    largestLoss,
+    winRate: divideOrNull(wins, approvedEvaluations.length),
+    maxDrawdown,
+    maxDrawdownPctOfGrossProfit: grossProfit > 0 ? maxDrawdown / grossProfit : null,
+    maxDrawdownPctOfTotalProfit: totalProfit > 0 ? maxDrawdown / totalProfit : null,
+    recoveryFactor: maxDrawdown > 0 ? totalProfit / maxDrawdown : null,
+    ulcerIndex: Math.sqrt(drawdownSquares / approvedEvaluations.length),
+    maxConsecutiveWins,
+    maxConsecutiveLosses
+  };
+};
 var summarizeAiTrainEvaluations = (evaluations) => {
   let approved = 0;
   let rejected = 0;
@@ -1746,6 +1859,7 @@ var summarizeAiTrainEvaluations = (evaluations) => {
     avgApprovedTradesPerDay,
     avgApprovedTradesPerWeek,
     expectancyDelta,
+    approvedRisk: summarizeApprovedRisk(evaluations),
     qualityBuckets: [...bucketMap.values()].sort(
       (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
     )
@@ -1760,6 +1874,16 @@ var getDirectionSortKey = (direction) => {
   }
   return 2;
 };
+var getMonthKey = (timestamp) => {
+  if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
+    return "UNKNOWN";
+  }
+  return new Date(timestamp).toISOString().slice(0, 7);
+};
+var isDirectionMatchAtThreshold = (evaluation, threshold) => {
+  const directionMatches = typeof evaluation.modelDirectionMatches === "boolean" ? evaluation.modelDirectionMatches : evaluation.aiApproved;
+  return directionMatches === true && evaluation.quality != null && evaluation.quality >= threshold;
+};
 var summarizeAiTrainEvaluationsByDirection = (evaluations) => {
   const grouped = /* @__PURE__ */ new Map();
   for (const evaluation of evaluations) {
@@ -1775,6 +1899,984 @@ var summarizeAiTrainEvaluationsByDirection = (evaluations) => {
     summary: summarizeAiTrainEvaluations(directionEvaluations)
   }));
 };
+var summarizeAiTrainEvaluationsByMonth = (evaluations) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    const month = getMonthKey(evaluation.timestamp);
+    const bucket = grouped.get(month) ?? [];
+    bucket.push(evaluation);
+    grouped.set(month, bucket);
+  }
+  return [...grouped.entries()].sort(([leftMonth], [rightMonth]) => leftMonth.localeCompare(rightMonth)).map(([month, monthEvaluations]) => ({
+    month,
+    summary: summarizeAiTrainEvaluations(monthEvaluations)
+  }));
+};
+var summarizeAiTrainEvaluationsByQualityThreshold = (evaluations, thresholds = [3, 4, 5]) => thresholds.map((threshold) => ({
+  threshold,
+  label: `q${threshold}+`,
+  summary: summarizeAiTrainEvaluations(
+    evaluations.map((evaluation) => ({
+      ...evaluation,
+      aiApproved: isDirectionMatchAtThreshold(evaluation, threshold)
+    }))
+  )
+}));
+
+// src/lib/aiTrainCharts.ts
+var formatRatio = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+var formatPercent = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+var formatPercentValue = (value) => value == null ? "n/a" : `${value.toFixed(1)}%`;
+var formatSigned = (value) => value == null ? "n/a" : `${value >= 0 ? "+" : ""}${value.toFixed(2)}`;
+var formatNumber = (value) => value == null ? "n/a" : value.toFixed(2);
+var formatUtcWindowTimestamp = (timestamp) => {
+  if (timestamp == null || !Number.isFinite(timestamp)) {
+    return "n/a";
+  }
+  return new Date(timestamp).toISOString().replace("T", " ").replace(".000Z", " UTC");
+};
+var resolveMetricTone = (value) => {
+  if (value == null) {
+    return "default";
+  }
+  if (value > 0) {
+    return "success";
+  }
+  if (value < 0) {
+    return "error";
+  }
+  return "neutral";
+};
+var buildAiChartMetrics = (params) => {
+  const { summary, maxDrawdownPercent } = params;
+  const metrics = [
+    {
+      id: "maxDrawdown",
+      label: "Max drawdown",
+      value: formatPercentValue(maxDrawdownPercent),
+      tone: maxDrawdownPercent == null ? "default" : maxDrawdownPercent > 0 ? "warning" : "success"
+    },
+    {
+      id: "approved",
+      label: "Approved",
+      value: String(summary.approved)
+    },
+    {
+      id: "accuracy",
+      label: "Accuracy",
+      value: formatPercent(
+        summary.correct + summary.incorrect > 0 ? summary.correct / (summary.correct + summary.incorrect) : null
+      )
+    },
+    {
+      id: "precision",
+      label: "Precision",
+      value: formatPercent(summary.precisionApproved)
+    },
+    {
+      id: "recall",
+      label: "Recall",
+      value: formatPercent(summary.recallWinners)
+    },
+    {
+      id: "pnl",
+      label: "P&L",
+      value: formatSigned(summary.approvedRisk.totalProfit),
+      tone: resolveMetricTone(summary.approvedRisk.totalProfit)
+    },
+    {
+      id: "monthlyPnl",
+      label: "Monthly P&L",
+      value: formatSigned(summary.avgProfitApprovedPerMonth),
+      tone: resolveMetricTone(summary.avgProfitApprovedPerMonth)
+    },
+    {
+      id: "approvedPerDay",
+      label: "Approved/Day",
+      value: formatNumber(summary.avgApprovedTradesPerDay)
+    },
+    {
+      id: "avgProfit",
+      label: "Avg Profit",
+      value: formatSigned(summary.avgProfitApproved),
+      tone: resolveMetricTone(summary.avgProfitApproved)
+    }
+  ];
+  return metrics;
+};
+var buildAiChartDetails = (params) => {
+  const { summary, rows } = params;
+  let windowStart = null;
+  let windowEnd = null;
+  for (const row of rows) {
+    const timestamp = row.timestamp != null && Number.isFinite(row.timestamp) ? row.timestamp : null;
+    if (timestamp == null) {
+      continue;
+    }
+    if (windowStart == null || timestamp < windowStart) {
+      windowStart = timestamp;
+    }
+    if (windowEnd == null || timestamp > windowEnd) {
+      windowEnd = timestamp;
+    }
+  }
+  const directionDetails = summarizeAiTrainEvaluationsByDirection(rows).filter(({ direction }) => direction === "LONG" || direction === "SHORT").flatMap(({ direction, summary: directionSummary }) => [
+    {
+      id: `direction:${direction}:approved`,
+      label: `${direction} approved`,
+      value: String(directionSummary.approved)
+    },
+    {
+      id: `direction:${direction}:precision`,
+      label: `${direction} precision`,
+      value: formatRatio(directionSummary.precisionApproved)
+    },
+    {
+      id: `direction:${direction}:monthlyPnl`,
+      label: `${direction} monthly_pnl`,
+      value: formatSigned(directionSummary.avgProfitApprovedPerMonth),
+      tone: resolveMetricTone(directionSummary.avgProfitApprovedPerMonth)
+    },
+    {
+      id: `direction:${direction}:pnl`,
+      label: `${direction} pnl`,
+      value: formatSigned(directionSummary.approvedRisk.totalProfit),
+      tone: resolveMetricTone(directionSummary.approvedRisk.totalProfit)
+    },
+    {
+      id: `direction:${direction}:avgProfit`,
+      label: `${direction} avg_profit`,
+      value: formatSigned(directionSummary.avgProfitApproved),
+      tone: resolveMetricTone(directionSummary.avgProfitApproved)
+    }
+  ]);
+  const symbolDetails = [
+    ...rows.reduce((grouped, row) => {
+      if (!row.symbol) {
+        return grouped;
+      }
+      const symbolRows = grouped.get(row.symbol) ?? [];
+      symbolRows.push(row);
+      grouped.set(row.symbol, symbolRows);
+      return grouped;
+    }, /* @__PURE__ */ new Map()).entries()
+  ].map(([symbol, symbolRows]) => {
+    const symbolSummary = summarizeAiTrainEvaluations(symbolRows);
+    return {
+      symbol,
+      summary: symbolSummary,
+      pnl: symbolSummary.approvedRisk.totalProfit
+    };
+  }).filter(({ summary: summary2 }) => summary2.approved > 0).sort(
+    (left, right) => Math.abs(right.pnl) - Math.abs(left.pnl) || right.pnl - left.pnl || left.symbol.localeCompare(right.symbol)
+  ).slice(0, 10).flatMap(({ symbol, summary: summary2, pnl }) => [
+    {
+      id: `symbol:${symbol}:pnl`,
+      label: `${symbol} pnl`,
+      value: formatSigned(pnl),
+      tone: resolveMetricTone(pnl)
+    },
+    {
+      id: `symbol:${symbol}:orders`,
+      label: `${symbol} approved`,
+      value: String(summary2.approved)
+    },
+    {
+      id: `symbol:${symbol}:winRate`,
+      label: `${symbol} win_rate`,
+      value: formatRatio(summary2.approvedRisk.winRate)
+    }
+  ]);
+  const details = [
+    {
+      id: "window",
+      label: "window",
+      value: `${formatUtcWindowTimestamp(windowStart)} -> ${formatUtcWindowTimestamp(windowEnd)}`
+    },
+    {
+      id: "approved",
+      label: "approved",
+      value: String(summary.approved)
+    },
+    {
+      id: "confusion",
+      label: "TP / FP / TN / FN",
+      value: `${summary.truePositive} / ${summary.falsePositive} / ${summary.trueNegative} / ${summary.falseNegative}`
+    },
+    {
+      id: "precisionApproved",
+      label: "precision_approved",
+      value: formatRatio(summary.precisionApproved)
+    },
+    {
+      id: "recallWinners",
+      label: "recall_winners",
+      value: formatRatio(summary.recallWinners)
+    },
+    {
+      id: "avgProfitAll",
+      label: "avg_profit_all",
+      value: formatSigned(summary.avgProfitAll),
+      tone: resolveMetricTone(summary.avgProfitAll)
+    },
+    {
+      id: "avgProfitApproved",
+      label: "avg_profit_approved",
+      value: formatSigned(summary.avgProfitApproved),
+      tone: resolveMetricTone(summary.avgProfitApproved)
+    },
+    {
+      id: "avgProfitApprovedPerDay",
+      label: "avg_profit_approved_per_day",
+      value: formatSigned(summary.avgProfitApprovedPerDay),
+      tone: resolveMetricTone(summary.avgProfitApprovedPerDay)
+    },
+    {
+      id: "avgProfitApprovedPerMonth",
+      label: "avg_profit_approved_per_month",
+      value: formatSigned(summary.avgProfitApprovedPerMonth),
+      tone: resolveMetricTone(summary.avgProfitApprovedPerMonth)
+    },
+    {
+      id: "avgApprovedTradesPerDay",
+      label: "avg_approved_trades_per_day",
+      value: formatNumber(summary.avgApprovedTradesPerDay)
+    },
+    {
+      id: "avgApprovedTradesPerWeek",
+      label: "avg_approved_trades_per_week",
+      value: formatNumber(summary.avgApprovedTradesPerWeek)
+    },
+    {
+      id: "expectancyDelta",
+      label: "expectancy_delta",
+      value: formatSigned(summary.expectancyDelta),
+      tone: resolveMetricTone(summary.expectancyDelta)
+    },
+    {
+      id: "maxLossStreak",
+      label: "max_loss_streak",
+      value: String(summary.approvedRisk.maxConsecutiveLosses),
+      tone: summary.approvedRisk.maxConsecutiveLosses > 0 ? "warning" : "success"
+    },
+    ...directionDetails,
+    ...symbolDetails
+  ];
+  return details;
+};
+var buildStrategyWideEquityCurve = (evaluations) => {
+  if (!evaluations.length) {
+    return [];
+  }
+  const sorted = [...evaluations].sort(
+    (left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0) || left.symbol.localeCompare(right.symbol) || left.signalId.localeCompare(right.signalId)
+  );
+  let amount = 100;
+  const firstTimestamp = sorted[0]?.timestamp ?? Date.now();
+  const orderLog = [[firstTimestamp, amount]];
+  for (const evaluation of sorted) {
+    amount += evaluation.profit;
+    orderLog.push([
+      evaluation.timestamp ?? firstTimestamp,
+      Number(amount.toFixed(4))
+    ]);
+  }
+  if (orderLog.length === 1) {
+    orderLog.push([firstTimestamp, amount]);
+  }
+  return orderLog;
+};
+var sortAiChartEvaluations = (evaluations) => [...evaluations].sort(
+  (left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0) || left.symbol.localeCompare(right.symbol) || left.signalId.localeCompare(right.signalId)
+);
+var toFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var buildStrategyWideOrders = (evaluations) => {
+  let amount = 100;
+  return sortAiChartEvaluations(evaluations).flatMap((evaluation, index) => {
+    const tradeResult = evaluation.tradeResult;
+    const equityBefore = amount;
+    amount = Number((amount + evaluation.profit).toFixed(4));
+    if (!tradeResult) {
+      return [];
+    }
+    const entryPrice = toFiniteNumber(tradeResult?.entryPrice);
+    const qty = toFiniteNumber(tradeResult?.qty);
+    const notional = entryPrice != null && qty != null ? Number((entryPrice * qty).toFixed(8)) : null;
+    return {
+      id: `${evaluation.signalId}:${evaluation.timestamp ?? index}`,
+      symbol: evaluation.symbol,
+      direction: tradeResult?.direction ?? evaluation.direction ?? null,
+      timestamp: evaluation.timestamp ?? tradeResult?.exitTimestamp ?? null,
+      entryTimestamp: tradeResult?.entryTimestamp ?? evaluation.timestamp ?? null,
+      exitTimestamp: tradeResult?.exitTimestamp ?? evaluation.timestamp ?? null,
+      exitReason: tradeResult?.exitReason ?? null,
+      pnl: evaluation.profit,
+      equityBefore,
+      equityAfter: amount,
+      qty,
+      notional,
+      requestedEntryPrice: toFiniteNumber(tradeResult?.requestedEntryPrice),
+      entryPrice,
+      requestedExitPrice: toFiniteNumber(tradeResult?.requestedExitPrice),
+      exitPrice: toFiniteNumber(tradeResult?.exitPrice),
+      openFee: toFiniteNumber(tradeResult?.openFee),
+      closeFee: toFiniteNumber(tradeResult?.closeFee),
+      fundingFee: toFiniteNumber(tradeResult?.fundingFee),
+      totalFee: toFiniteNumber(tradeResult?.totalFee),
+      entrySlippageBps: toFiniteNumber(tradeResult?.entrySlippageBps),
+      entryBaseSlippageBps: toFiniteNumber(tradeResult?.entryBaseSlippageBps),
+      entrySpreadBps: toFiniteNumber(tradeResult?.entrySpreadBps),
+      entrySpreadSlippageBps: toFiniteNumber(
+        tradeResult?.entrySpreadSlippageBps
+      ),
+      entryMarketImpactBps: toFiniteNumber(tradeResult?.entryMarketImpactBps),
+      entryDelayRiskBps: toFiniteNumber(tradeResult?.entryDelayRiskBps),
+      exitSlippageBps: toFiniteNumber(tradeResult?.exitSlippageBps),
+      exitBaseSlippageBps: toFiniteNumber(tradeResult?.exitBaseSlippageBps),
+      exitSpreadBps: toFiniteNumber(tradeResult?.exitSpreadBps),
+      exitSpreadSlippageBps: toFiniteNumber(tradeResult?.exitSpreadSlippageBps),
+      exitMarketImpactBps: toFiniteNumber(tradeResult?.exitMarketImpactBps),
+      exitDelayRiskBps: toFiniteNumber(tradeResult?.exitDelayRiskBps),
+      totalSlippageCost: toFiniteNumber(tradeResult?.totalSlippageCost),
+      sequence: evaluation.sequence ?? index + 1
+    };
+  });
+};
+var calculateMaxDrawdownPercent = (orderLog) => {
+  if (!orderLog.length) {
+    return null;
+  }
+  let peak = orderLog[0]?.[1] ?? 0;
+  let maxDrawdownPercent = 0;
+  for (const [, amount] of orderLog) {
+    if (!Number.isFinite(amount)) {
+      continue;
+    }
+    peak = Math.max(peak, amount);
+    if (peak <= 0) {
+      continue;
+    }
+    const drawdownPercent = (peak - amount) / peak * 100;
+    maxDrawdownPercent = Math.max(maxDrawdownPercent, drawdownPercent);
+  }
+  return Number(maxDrawdownPercent.toFixed(1));
+};
+var resolveAiVariantGroup = (params) => {
+  const normalizedConfigId = params.configId.trim();
+  if (!normalizedConfigId) {
+    return null;
+  }
+  return {
+    key: normalizedConfigId,
+    label: `config ${normalizedConfigId}`
+  };
+};
+var buildAiChartSnapshot = (params) => {
+  const {
+    evaluatedRows,
+    strategyName,
+    generatedAt,
+    runLabel,
+    minQuality,
+    datasetId
+  } = params;
+  const groupsByVariant = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluatedRows) {
+    const variantGroup = resolveAiVariantGroup({
+      configId: evaluation.configId
+    });
+    if (!variantGroup) {
+      continue;
+    }
+    const existingGroup = groupsByVariant.get(variantGroup.key);
+    if (existingGroup) {
+      existingGroup.rows.push(evaluation);
+      continue;
+    }
+    groupsByVariant.set(variantGroup.key, {
+      key: variantGroup.key,
+      label: variantGroup.label,
+      rows: [evaluation]
+    });
+  }
+  const variantGroups = [...groupsByVariant.values()].sort(
+    (left, right) => left.label.localeCompare(right.label)
+  );
+  const groupByVariant = variantGroups.length > 1;
+  const groups = groupByVariant ? variantGroups : [
+    {
+      key: strategyName,
+      label: "",
+      rows: evaluatedRows
+    }
+  ];
+  const cards = [];
+  for (const threshold of [minQuality]) {
+    for (const group of groups) {
+      const thresholdEvaluations = group.rows.map((evaluation) => ({
+        ...evaluation,
+        aiApproved: evaluation.modelDirection === evaluation.direction && evaluation.quality != null && evaluation.quality >= threshold
+      }));
+      const summary = summarizeAiTrainEvaluations(thresholdEvaluations);
+      const approvedRows = thresholdEvaluations.filter(
+        (evaluation) => evaluation.aiApproved
+      );
+      const orderLog = buildStrategyWideEquityCurve(approvedRows);
+      const orders = buildStrategyWideOrders(approvedRows);
+      cards.push({
+        cardId: `${strategyName}-${group.key}-q${threshold}-${generatedAt}`,
+        generatedAt,
+        strategyName,
+        title: groupByVariant ? `${strategyName} \xB7 ${group.label}` : strategyName,
+        subtitle: runLabel ? `q${threshold}+ \xB7 ${runLabel}` : `q${threshold}+`,
+        datasetId,
+        symbols: [
+          ...new Set(
+            group.rows.map((evaluation) => evaluation.symbol).filter(Boolean)
+          )
+        ].sort(),
+        orderLog,
+        orders,
+        stat: null,
+        metrics: buildAiChartMetrics({
+          summary,
+          maxDrawdownPercent: calculateMaxDrawdownPercent(orderLog)
+        }),
+        details: buildAiChartDetails({
+          summary,
+          rows: thresholdEvaluations
+        }),
+        tags: groupByVariant ? [`q${threshold}+`, group.label] : [`q${threshold}+`]
+      });
+    }
+  }
+  return {
+    mode: "ai",
+    generatedAt,
+    runLabel,
+    strategies: cards
+  };
+};
+
+// src/lib/aiTrainEvaluationDump.ts
+var BASE_CONTEXT_FEATURE_SECTIONS = [
+  "regime",
+  "structure",
+  "participation",
+  "relative",
+  "derivatives",
+  "mtf",
+  "gateFeatures"
+];
+var asRecord = (value) => typeof value === "object" && value != null && !Array.isArray(value) ? value : null;
+var collectStrategyGateFeatures = (baseContext) => {
+  const entries = Object.entries(baseContext).filter(
+    ([key, value]) => key !== "gateFeatures" && key.endsWith("GateFeatures") && asRecord(value) != null
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+var pickBaseContextFeatureSections = (baseContext) => Object.fromEntries(
+  BASE_CONTEXT_FEATURE_SECTIONS.map((section) => [
+    section,
+    baseContext[section] ?? null
+  ])
+);
+var buildAiTrainEvaluationFeatureSnapshot = ({
+  additionalIndicators,
+  mode
+}) => {
+  if (mode === "none") {
+    return void 0;
+  }
+  const additional = asRecord(additionalIndicators);
+  const baseContext = asRecord(additional?.baseContext);
+  if (!baseContext) {
+    return {
+      baseContextAvailable: false
+    };
+  }
+  const strategyGateFeatures = collectStrategyGateFeatures(baseContext);
+  const snapshot = {
+    baseContextAvailable: true,
+    gateFeatures: baseContext.gateFeatures ?? null,
+    ...strategyGateFeatures ? { strategyGateFeatures } : {}
+  };
+  if (mode === "baseContext") {
+    snapshot.baseContext = pickBaseContextFeatureSections(baseContext);
+  }
+  return snapshot;
+};
+
+// src/lib/aiTrainOptions.ts
+var parseTimestampFilter = (value) => {
+  if (value == null || String(value).trim() === "") {
+    return null;
+  }
+  const text = String(value).trim();
+  const numeric = Number(text);
+  if (Number.isFinite(numeric)) {
+    return numeric;
+  }
+  const parsed = Date.parse(text);
+  if (Number.isFinite(parsed)) {
+    return parsed;
+  }
+  throw new Error(
+    `Invalid timestamp filter "${text}". Use an ISO date or epoch milliseconds.`
+  );
+};
+var parseTrailingPeriodMs = (value) => {
+  if (value == null || String(value).trim() === "") {
+    return null;
+  }
+  const text = String(value).trim().toLowerCase();
+  const match = text.match(
+    /^(?:last)?(\d+)(d|day|days|w|week|weeks|m|month|months|y|year|years)$/
+  );
+  if (!match) {
+    throw new Error(
+      `Invalid --period value "${String(value)}". Use values like last365d, 90d, 12w, or 1y.`
+    );
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const dayMs = 24 * 60 * 60 * 1e3;
+  if (unit.startsWith("w")) {
+    return amount * 7 * dayMs;
+  }
+  if (unit.startsWith("m")) {
+    return amount * 30.4375 * dayMs;
+  }
+  if (unit.startsWith("y")) {
+    return amount * 365 * dayMs;
+  }
+  return amount * dayMs;
+};
+var parseQualityThresholds = (value) => {
+  const raw = String(value ?? "3,4,5").split(",").map((part) => Number(part.trim())).filter((part) => Number.isFinite(part)).map((part) => Math.trunc(part)).filter((part) => part > 0);
+  return [...new Set(raw)].sort((left, right) => left - right);
+};
+var parseTerminalWindowDays = (value) => {
+  const raw = String(value ?? "90,30,7").split(",").map((part) => Number(part.trim())).filter((part) => Number.isFinite(part)).map((part) => Math.trunc(part)).filter((part) => part > 0);
+  return [...new Set(raw)].sort((left, right) => right - left);
+};
+var parseDumpFeatureMode = (value) => {
+  const text = String(value ?? "none").trim().toLowerCase();
+  if (!text || text === "none" || text === "false" || text === "0") {
+    return "none";
+  }
+  if (text === "gatefeatures" || text === "gate-features") {
+    return "gateFeatures";
+  }
+  if (text === "basecontext" || text === "base-context") {
+    return "baseContext";
+  }
+  throw new Error(
+    `Invalid --dumpFeatures value "${String(value)}". Use none, gateFeatures, or baseContext.`
+  );
+};
+var hasCliOption = ({
+  argv,
+  longName,
+  shortName
+}) => argv.some(
+  (arg) => arg === `--${longName}` || arg.startsWith(`--${longName}=`) || arg === `-${shortName}` || arg.startsWith(`-${shortName}=`)
+);
+var resolveAiTrainRecentLimit = ({
+  argv,
+  recentValue,
+  hasDateFilter,
+  defaultRecent = 50
+}) => {
+  const hasExplicitRecent = hasCliOption({
+    argv,
+    longName: "recent",
+    shortName: "n"
+  });
+  const selectedRecent = hasDateFilter && !hasExplicitRecent ? 0 : recentValue;
+  const parsed = Number(selectedRecent);
+  return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : defaultRecent;
+};
+
+// src/lib/aiTrainResearch.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var RESEARCH_CONTEXT_ENV_KEYS = [
+  "AI_MODE",
+  "MIN_AI_QUALITY",
+  "INTERVAL",
+  "DERIVATIVES_CONTEXT_ENABLED",
+  "DERIVATIVES_CONTEXT_TARGET_ENABLED",
+  "DERIVATIVES_CONTEXT_INTERVALS",
+  "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
+  "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
+  "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
+  "COINMARKETCAP_CONTEXT_ENABLED",
+  "COINMARKETCAP_CONTEXT_MAX_AGE_MS",
+  "COINMARKETCAP_CONTEXT_EXCHANGE_LIQUIDITY_ENABLED",
+  "COINMARKETCAP_CONTEXT_EXCHANGE_SLUGS",
+  "COINMARKETCAP_CONTEXT_FEAR_GREED_ENABLED",
+  "COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS",
+  "COINMARKETCAP_CONTEXT_BACKFILL_ENABLED",
+  "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
+  "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS"
+];
+var normalizeForStableJson = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeForStableJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+    );
+  }
+  return value;
+};
+var fingerprintResearchValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var getTimestampRange = (evaluations) => {
+  let minTimestamp = null;
+  let maxTimestamp = null;
+  for (const evaluation of evaluations) {
+    const timestamp = evaluation.timestamp;
+    if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
+      continue;
+    }
+    minTimestamp = minTimestamp == null ? timestamp : Math.min(minTimestamp, timestamp);
+    maxTimestamp = maxTimestamp == null ? timestamp : Math.max(maxTimestamp, timestamp);
+  }
+  return { minTimestamp, maxTimestamp };
+};
+var summarizeAiTrainCoverage = (evaluations, now = Date.now()) => {
+  const { minTimestamp, maxTimestamp } = getTimestampRange(evaluations);
+  const timestamped = evaluations.filter(
+    (evaluation) => typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp)
+  ).length;
+  return {
+    timestamped,
+    missingTimestamps: evaluations.length - timestamped,
+    minTimestamp,
+    maxTimestamp,
+    spanDays: minTimestamp == null || maxTimestamp == null ? null : (maxTimestamp - minTimestamp) / DAY_MS2,
+    dataLagDays: maxTimestamp == null ? null : Math.max(0, (now - maxTimestamp) / DAY_MS2)
+  };
+};
+var summarizeAiTrainRejectReasons = (evaluations, limit = 5) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    if (evaluation.aiApproved || !evaluation.rejectReason) {
+      continue;
+    }
+    for (const reason of evaluation.rejectReason.split(";").map((part) => part.trim()).filter(Boolean)) {
+      counts.set(reason, (counts.get(reason) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort(
+    (left, right) => right[1] - left[1] || left[0].localeCompare(right[0])
+  ).slice(0, limit).map(([reason, count]) => ({ reason, count }));
+};
+var summarizeAiTrainTerminalWindows = (evaluations, windowDays) => {
+  const { minTimestamp, maxTimestamp } = getTimestampRange(evaluations);
+  if (minTimestamp == null || maxTimestamp == null) {
+    return [];
+  }
+  return windowDays.map((days) => {
+    const requestedSince = maxTimestamp - days * DAY_MS2;
+    const since = Math.max(minTimestamp, requestedSince);
+    const selected = evaluations.filter(
+      (evaluation) => typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp) && evaluation.timestamp >= requestedSince && evaluation.timestamp <= maxTimestamp
+    );
+    const coverageDays = Math.max(1, (maxTimestamp - since) / DAY_MS2);
+    const outcome = summarizeAiTrainEvaluations(selected);
+    return {
+      label: `last${days}d`,
+      days,
+      complete: minTimestamp <= requestedSince,
+      since,
+      until: maxTimestamp,
+      coverageDays,
+      selected: selected.length,
+      approvedPerCalendarDay: outcome.approved / coverageDays,
+      outcome,
+      topRejectReasons: summarizeAiTrainRejectReasons(selected)
+    };
+  });
+};
+var readOptionalFile = async (filePath) => {
+  try {
+    return await import_promises.default.readFile(filePath);
+  } catch {
+    return null;
+  }
+};
+var getGitLineage = (projectRoot) => {
+  try {
+    const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const status = (0, import_node_child_process.execFileSync)(
+      "git",
+      ["status", "--porcelain", "--untracked-files=no"],
+      {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    return { gitSha: gitSha || null, gitDirty: status.length > 0 };
+  } catch {
+    return { gitSha: null, gitDirty: null };
+  }
+};
+var resolveGateFingerprint = async (projectRoot, strategyName, gitSha) => {
+  const relativeCandidates = [
+    `packages/strategies/src/${strategyName}/adapters/ai.ts`,
+    `packages/strategies/src/${strategyName}/guardrails.ts`,
+    `packages/strategies/src/${strategyName}/config.ts`,
+    "packages/node/src/ai.ts"
+  ];
+  const optionalSourceEntries = await Promise.all(
+    relativeCandidates.map(async (relativePath) => {
+      const content = await readOptionalFile(
+        import_node_path.default.join(projectRoot, relativePath)
+      );
+      return content == null ? null : { relativePath, content };
+    })
+  );
+  const sourceEntries = [];
+  for (const entry of optionalSourceEntries) {
+    if (entry != null) {
+      sourceEntries.push(entry);
+    }
+  }
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  return {
+    gateFingerprint: hash.digest("hex").slice(0, 16),
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+  };
+};
+var buildAiTrainLineage = async ({
+  projectRoot,
+  strategyName,
+  configIds,
+  runContext,
+  env = process.env
+}) => {
+  const { gitSha, gitDirty } = getGitLineage(projectRoot);
+  const gate = await resolveGateFingerprint(projectRoot, strategyName, gitSha);
+  const normalizedConfigIds = [...new Set(configIds.filter(Boolean))].sort();
+  const context = {
+    ...Object.fromEntries(
+      RESEARCH_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
+    ),
+    ...runContext
+  };
+  return {
+    gitSha,
+    gitDirty,
+    ...gate,
+    configIdsFingerprint: fingerprintResearchValue(normalizedConfigIds),
+    configIds: normalizedConfigIds,
+    contextFingerprint: fingerprintResearchValue(context),
+    context
+  };
+};
+
+// src/lib/aiTrainQuarantine.ts
+var import_crypto = require("crypto");
+var DAY_MS3 = 24 * 60 * 60 * 1e3;
+var normalizeKeyPart = (value, fallback) => {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const trimmed = value.trim();
+  return trimmed || fallback;
+};
+var getProfitFactor = ({
+  grossProfit,
+  grossLoss
+}) => {
+  if (grossLoss <= 0) {
+    return grossProfit > 0 ? null : 0;
+  }
+  return grossProfit / grossLoss;
+};
+var createEmptyState = () => ({
+  quarantineUntil: null,
+  approvedLosses: 0,
+  grossProfit: 0,
+  grossLoss: 0
+});
+var applyAiTrainSymbolQuarantine = (evaluations, options) => {
+  const summary = {
+    enabled: options.enabled,
+    minApprovedLosses: options.minApprovedLosses,
+    minProfitFactor: options.minProfitFactor,
+    cooldownDays: options.cooldownDays,
+    blocked: 0,
+    events: []
+  };
+  if (!options.enabled) {
+    return {
+      evaluations: evaluations.map((evaluation) => ({
+        ...evaluation,
+        rawAiApproved: evaluation.aiApproved
+      })),
+      summary
+    };
+  }
+  const cooldownMs = Math.max(0, options.cooldownDays) * DAY_MS3;
+  const minApprovedLosses = Math.max(1, Math.trunc(options.minApprovedLosses));
+  const minProfitFactor = Math.max(0, options.minProfitFactor);
+  const states = /* @__PURE__ */ new Map();
+  const ordered = evaluations.map((evaluation, index) => ({ evaluation, index })).sort((left, right) => {
+    const leftTimestamp = typeof left.evaluation.timestamp === "number" && Number.isFinite(left.evaluation.timestamp) ? left.evaluation.timestamp : Number.POSITIVE_INFINITY;
+    const rightTimestamp = typeof right.evaluation.timestamp === "number" && Number.isFinite(right.evaluation.timestamp) ? right.evaluation.timestamp : Number.POSITIVE_INFINITY;
+    return leftTimestamp - rightTimestamp || left.index - right.index;
+  });
+  const result = evaluations.map((evaluation) => ({
+    ...evaluation,
+    rawAiApproved: evaluation.aiApproved
+  }));
+  for (const { evaluation, index } of ordered) {
+    const timestamp = typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp) ? evaluation.timestamp : null;
+    const strategy = normalizeKeyPart(evaluation.strategy, "unknown");
+    const symbol = normalizeKeyPart(evaluation.symbol, "unknown");
+    const key = `${strategy}:${symbol}`;
+    const state = states.get(key) ?? createEmptyState();
+    states.set(key, state);
+    if (timestamp != null && state.quarantineUntil != null && timestamp >= state.quarantineUntil) {
+      state.quarantineUntil = null;
+      state.approvedLosses = 0;
+      state.grossProfit = 0;
+      state.grossLoss = 0;
+    }
+    if (evaluation.aiApproved && timestamp != null && state.quarantineUntil != null && timestamp < state.quarantineUntil) {
+      result[index] = {
+        ...result[index],
+        aiApproved: false
+      };
+      summary.blocked += 1;
+      continue;
+    }
+    if (!evaluation.aiApproved) {
+      continue;
+    }
+    if (evaluation.profit > 0) {
+      state.grossProfit += evaluation.profit;
+    } else if (evaluation.profit < 0) {
+      state.grossLoss += Math.abs(evaluation.profit);
+      state.approvedLosses += 1;
+    }
+    const profitFactor = getProfitFactor(state);
+    if (timestamp != null && cooldownMs > 0 && state.approvedLosses >= minApprovedLosses && profitFactor != null && profitFactor < minProfitFactor) {
+      state.quarantineUntil = timestamp + cooldownMs;
+      summary.events.push({
+        strategy,
+        symbol,
+        startedAt: timestamp,
+        until: state.quarantineUntil,
+        approvedLosses: state.approvedLosses,
+        profitFactor,
+        grossProfit: state.grossProfit,
+        grossLoss: state.grossLoss
+      });
+    }
+  }
+  return {
+    evaluations: result,
+    summary
+  };
+};
+var stableStringify = (value) => {
+  if (value == null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+};
+var hashContext = (row) => {
+  const payload = row.payload;
+  const signal = payload?.signal;
+  const additional = payload?.additionalIndicators && typeof payload.additionalIndicators === "object" && !Array.isArray(payload.additionalIndicators) ? payload.additionalIndicators : {};
+  const context = {
+    prices: signal?.prices ?? null,
+    trendShiftContext: additional.trendShiftContext ?? null,
+    marketContext: additional.marketContext ?? null
+  };
+  return (0, import_crypto.createHash)("sha1").update(stableStringify(context)).digest("hex");
+};
+var summarizeAiTrainDuplicateSignals = (rows) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const strategy = normalizeKeyPart(row.strategyName, "unknown");
+    const symbol = normalizeKeyPart(row.symbol, "unknown");
+    const direction = normalizeKeyPart(row.direction, "UNKNOWN");
+    const timestamp = Number(row.timestamp);
+    const profit = Number(row.profit);
+    const key = [
+      strategy,
+      symbol,
+      direction,
+      Number.isFinite(timestamp) ? timestamp : "no_timestamp",
+      Number.isFinite(profit) ? profit : "no_profit",
+      hashContext(row)
+    ].join("|");
+    const group = groups.get(key) ?? {
+      key,
+      strategy,
+      symbol,
+      direction,
+      timestamp: Number.isFinite(timestamp) ? timestamp : 0,
+      count: 0,
+      totalProfit: 0
+    };
+    group.count += 1;
+    group.totalProfit += Number.isFinite(profit) ? profit : 0;
+    groups.set(key, group);
+  }
+  const duplicateGroups = [...groups.values()].filter((group) => group.count > 1).sort(
+    (left, right) => left.totalProfit - right.totalProfit || right.count - left.count || left.key.localeCompare(right.key)
+  );
+  return {
+    groups: duplicateGroups.length,
+    rows: duplicateGroups.reduce((total, group) => total + group.count, 0),
+    maxGroupSize: duplicateGroups.reduce(
+      (max, group) => Math.max(max, group.count),
+      0
+    ),
+    worstGroups: duplicateGroups.slice(0, 10)
+  };
+};
+
+// src/lib/aiTrainDataset.ts
+var extractSignalFromAiDatasetRow = (row) => {
+  const { payload } = row;
+  return {
+    ...payload.signal,
+    strategy: payload.signal.strategy,
+    figures: payload.figures ?? {},
+    indicators: payload.indicators ?? {},
+    additionalIndicators: payload.additionalIndicators ?? {},
+    prices: payload.signal.prices
+  };
+};
 
 // src/scripts/aiTrain.ts
 var ListIt = require_list_it();
@@ -1791,38 +2893,103 @@ import_args.default.option(
   50
 );
 import_args.default.option(
-  "skip",
+  ["k", "skip"],
   "How many recent trades to skip from the end before selecting replay rows",
   0
 );
 import_args.default.option(
   ["p", "parallel"],
   "Concurrent AI requests during replay",
-  import_constants.AI_CONCURRENCY_LIMIT
+  import_constants2.AI_CONCURRENCY_LIMIT
 );
 import_args.default.option(
-  "model",
+  ["m", "model"],
   "OpenRouter model id override for this replay run",
   import_ai2.DEFAULT_AI_MODEL
 );
-import_args.default.option("minQuality", "Minimum AI quality required to approve entry", 4);
 import_args.default.option(
-  "localOnly",
+  ["M", "minQuality"],
+  "Minimum AI quality required to approve entry",
+  4
+);
+import_args.default.option(
+  ["l", "localOnly"],
   "Replay deterministic adapter gate without AI provider calls",
   false
 );
-import_args.default.option("json", "Print structured JSON summary", false);
+import_args.default.option(["U", "user"], "Use user config", "root");
+import_args.default.option(
+  ["c", "chart"],
+  "Save compact AI approval chart data for the strategies UI",
+  false
+);
+import_args.default.option(["j", "json"], "Print structured JSON summary", false);
+import_args.default.option(
+  ["S", "since"],
+  "Only evaluate rows at or after this timestamp (ISO date or epoch ms)",
+  ""
+);
+import_args.default.option(
+  ["u", "until"],
+  "Only evaluate rows at or before this timestamp (ISO date or epoch ms)",
+  ""
+);
+import_args.default.option(
+  ["P", "period"],
+  "Evaluate a trailing selected-row period such as last365d, last90d, or last30d",
+  ""
+);
+import_args.default.option(
+  ["q", "qualityThresholds"],
+  "Comma-separated qN+ thresholds to summarize",
+  "3,4,5"
+);
+import_args.default.option(
+  ["W", "terminalWindows"],
+  "Comma-separated terminal dataset windows in days; use --terminalWindows=90,30,7",
+  "90,30,7"
+);
+import_args.default.option(
+  ["d", "dumpEvaluations"],
+  "Write evaluated rows as JSONL for offline pocket research",
+  ""
+);
+import_args.default.option(
+  ["G", "dumpFeatures"],
+  "Feature snapshot to include in --dumpEvaluations rows: none, gateFeatures, or baseContext",
+  "none"
+);
+import_args.default.option(
+  ["Q", "symbolQuarantine"],
+  "Apply ordered per-strategy/per-symbol quarantine overlay to approved rows",
+  false
+);
+import_args.default.option(
+  ["L", "symbolQuarantineMinLosses"],
+  "Approved losses required before symbol quarantine can trigger",
+  5
+);
+import_args.default.option(
+  ["F", "symbolQuarantineMinProfitFactor"],
+  "Minimum symbol profit factor required to avoid quarantine",
+  1
+);
+import_args.default.option(
+  ["D", "symbolQuarantineDays"],
+  "How many days to keep a symbol quarantined after trigger",
+  14
+);
 var flags = import_args.default.parse(process.argv);
 var createListIt = () => new ListIt({
   autoAlign: true,
   headerUnderline: true
 });
 var createTable = (headers, rows) => createListIt().setHeaderRow(headers).d(rows).toString();
-var formatRatio = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+var formatRatio2 = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
 var formatProfit = (value) => value == null ? "n/a" : value.toFixed(2);
 var formatMetricNumber = (value) => value == null ? "n/a" : value.toFixed(2);
 var colorizeRatio = (value) => {
-  const text = formatRatio(value);
+  const text = formatRatio2(value);
   if (value == null) {
     return import_chalk.default.gray(text);
   }
@@ -1876,6 +3043,10 @@ var normalizePositiveInt = (value, fallback) => {
   const parsed = Number(value);
   return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : fallback;
 };
+var normalizeNonNegativeNumber = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
 var normalizeQuality = (analysis) => {
   const quality = Number(analysis?.quality);
   return Number.isFinite(quality) ? Math.round(quality) : null;
@@ -1889,30 +3060,81 @@ var listMergedFiles = async (params) => {
   const { outDir, strategyName } = params;
   let entries = [];
   try {
-    entries = await import_promises.default.readdir(outDir);
+    entries = await import_promises2.default.readdir(outDir);
   } catch {
     return [];
   }
   const prefix = strategyName ? `ai-dataset-${(0, import_ai.toFileToken)(strategyName)}-merged-` : "ai-dataset-";
-  return entries.filter((name) => name.startsWith(prefix)).filter((name) => name.includes("-merged-") && name.endsWith(".jsonl")).sort().map((name) => import_path.default.join(outDir, name));
+  return entries.filter((name) => name.startsWith(prefix)).filter((name) => {
+    if (!name.endsWith(".jsonl") || !name.includes("-merged-")) {
+      return false;
+    }
+    return /-merged-\d+\.jsonl$/.test(name) || /-merged-\d+-part\d+\.jsonl$/.test(name);
+  }).sort().map((name) => import_path.default.join(outDir, name));
 };
 var deriveStrategyNameFromFile = (filePath) => {
-  const match = import_path.default.basename(filePath).match(/^ai-dataset-(.+)-merged-\d+\.jsonl$/);
+  const match = import_path.default.basename(filePath).match(/^ai-dataset-(.+)-merged-\d+(?:-part\d+)?\.jsonl$/);
   return match?.[1] ? match[1] : "unknown";
 };
-var extractSignalFromDatasetRow = (row) => {
-  const { payload } = row;
+var getMergedGroupId = (filePath) => {
+  const match = import_path.default.basename(filePath).match(/^ai-dataset-(.+)-merged-(\d+)(?:-part(\d+))?\.jsonl$/);
+  if (!match) {
+    return null;
+  }
   return {
-    ...payload.signal,
-    strategy: payload.signal.strategy,
-    figures: payload.figures ?? {},
-    indicators: payload.indicators ?? {},
-    additionalIndicators: payload.additionalIndicators ?? {},
-    prices: payload.signal.prices
+    strategyToken: match[1],
+    mergeId: match[2]
   };
 };
+var sortDatasetPartPaths = (filePaths) => [...filePaths].sort((left, right) => {
+  const leftMatch = import_path.default.basename(left).match(/-part(\d+)\.jsonl$/);
+  const rightMatch = import_path.default.basename(right).match(/-part(\d+)\.jsonl$/);
+  const leftPart = leftMatch ? Number(leftMatch[1]) : 0;
+  const rightPart = rightMatch ? Number(rightMatch[1]) : 0;
+  return leftPart - rightPart || left.localeCompare(right);
+});
+var resolveMergedDatasetFiles = async ({
+  outDir,
+  strategyName,
+  explicitFile
+}) => {
+  const mergedFiles = await listMergedFiles({
+    outDir,
+    strategyName
+  });
+  if (!mergedFiles.length) {
+    throw new Error(
+      strategyName ? `No merged AI dataset found for strategy "${strategyName}" in ${outDir}. Run yarn ai-export first.` : `No merged AI dataset found in ${outDir}. Run yarn ai-export first.`
+    );
+  }
+  const resolvedExplicitFile = explicitFile ? import_path.default.resolve(explicitFile) : null;
+  if (resolvedExplicitFile) {
+    const groupId = getMergedGroupId(resolvedExplicitFile);
+    if (!groupId) {
+      return [resolvedExplicitFile];
+    }
+    const groupedFiles = sortDatasetPartPaths(
+      mergedFiles.filter((candidate) => {
+        const candidateGroup = getMergedGroupId(candidate);
+        return candidateGroup?.strategyToken === groupId.strategyToken && candidateGroup?.mergeId === groupId.mergeId;
+      })
+    );
+    return groupedFiles.length ? groupedFiles : [resolvedExplicitFile];
+  }
+  const latestFile = mergedFiles[mergedFiles.length - 1];
+  const latestGroupId = getMergedGroupId(latestFile);
+  if (!latestGroupId) {
+    return [latestFile];
+  }
+  return sortDatasetPartPaths(
+    mergedFiles.filter((candidate) => {
+      const candidateGroup = getMergedGroupId(candidate);
+      return candidateGroup?.strategyToken === latestGroupId.strategyToken && candidateGroup?.mergeId === latestGroupId.mergeId;
+    })
+  );
+};
 var resolvePromptRunContext = (row) => {
-  const signal = extractSignalFromDatasetRow(row);
+  const signal = extractSignalFromAiDatasetRow(row);
   return {
     signal,
     promptPair: (0, import_ai2.buildAiPrompts)(signal)
@@ -1993,71 +3215,152 @@ var printSection = (title, table) => {
   console.log(table);
   console.log("");
 };
-var resolveDatasetFile = async () => {
+var persistAiChartSnapshot = async (params) => {
+  const {
+    strategyName,
+    evaluatedRows,
+    model,
+    mode,
+    userName,
+    minQuality,
+    datasetId
+  } = params;
+  const generatedAt = Date.now();
+  const runLabel = mode === model ? "" : `${mode}:${model}`;
+  const snapshot = buildAiChartSnapshot({
+    evaluatedRows,
+    strategyName,
+    generatedAt,
+    runLabel,
+    minQuality,
+    datasetId
+  });
+  await Promise.all(
+    snapshot.strategies.map(
+      (card) => (0, import_redis.setData)(import_redis.redisKeys.strategyChartCard(userName, "ai", card.cardId), card, {
+        expire: import_constants.TTL_1M
+      })
+    )
+  );
+  return snapshot;
+};
+var resolveDatasetFiles = async () => {
   const explicitFile = String(flags.file || "").trim();
-  if (explicitFile) {
-    return import_path.default.resolve(explicitFile);
-  }
   const outDir = String(flags.outDir || "data/ai/export");
   const strategyName = String(flags.strategy || "").trim() || void 0;
-  const mergedFiles = await listMergedFiles({
+  return resolveMergedDatasetFiles({
     outDir,
-    strategyName
+    strategyName,
+    explicitFile
   });
-  if (!mergedFiles.length) {
-    throw new Error(
-      strategyName ? `No merged AI dataset found for strategy "${strategyName}" in ${outDir}. Run yarn ai-export first.` : `No merged AI dataset found in ${outDir}. Run yarn ai-export first.`
-    );
-  }
-  return mergedFiles[mergedFiles.length - 1];
+};
+var getDatasetRowTimestamp = (row) => {
+  const timestamp = Number(row.timestamp);
+  return Number.isFinite(timestamp) ? timestamp : null;
+};
+var findMaxSelectedTimestamp = async ({
+  filePaths,
+  recent,
+  skip
+}) => {
+  let maxTimestamp = null;
+  await (0, import_ai.streamAiDatasetRows)({
+    filePaths,
+    limitFromEnd: recent,
+    skipFromEnd: skip,
+    onRow: async (row) => {
+      const timestamp = getDatasetRowTimestamp(row);
+      if (timestamp != null) {
+        maxTimestamp = maxTimestamp == null ? timestamp : Math.max(maxTimestamp, timestamp);
+      }
+    }
+  });
+  return maxTimestamp;
 };
 var main = async () => {
-  const recent = normalizeInt(flags.recent, 50);
   const skip = normalizeInt(flags.skip, 0);
   const minQuality = normalizeInt(flags.minQuality, 4);
   const localOnly = Boolean(flags.localOnly);
+  const saveChart = Boolean(flags.chart);
   const jsonOutput = Boolean(flags.json);
+  const sinceInput = parseTimestampFilter(flags.since);
+  const untilInput = parseTimestampFilter(flags.until);
+  const trailingPeriodMs = parseTrailingPeriodMs(flags.period);
+  const periodLabel = String(flags.period || "").trim() || null;
+  const hasDateFilter = trailingPeriodMs != null || sinceInput != null || untilInput != null;
+  const recent = resolveAiTrainRecentLimit({
+    argv: process.argv,
+    recentValue: flags.recent,
+    hasDateFilter
+  });
+  const qualityThresholds = parseQualityThresholds(flags.qualityThresholds);
+  const terminalWindowDays = parseTerminalWindowDays(flags.terminalWindows);
+  const dumpEvaluationsPath = String(flags.dumpEvaluations || "").trim();
+  const dumpFeatureMode = parseDumpFeatureMode(flags.dumpFeatures);
+  if (dumpFeatureMode !== "none" && !dumpEvaluationsPath) {
+    throw new Error("--dumpFeatures requires --dumpEvaluations.");
+  }
+  const symbolQuarantineEnabled = Boolean(flags.symbolQuarantine);
+  const symbolQuarantineMinLosses = normalizePositiveInt(
+    flags.symbolQuarantineMinLosses,
+    5
+  );
+  const symbolQuarantineMinProfitFactor = normalizeNonNegativeNumber(
+    flags.symbolQuarantineMinProfitFactor,
+    1
+  );
+  const symbolQuarantineDays = normalizeNonNegativeNumber(
+    flags.symbolQuarantineDays,
+    14
+  );
+  const userName = String(flags.user || "root").trim() || "root";
   const model = String(flags.model || import_ai2.DEFAULT_AI_MODEL).trim() || import_ai2.DEFAULT_AI_MODEL;
-  const parallel = normalizePositiveInt(flags.parallel, import_constants.AI_CONCURRENCY_LIMIT);
+  const parallel = normalizePositiveInt(flags.parallel, import_constants2.AI_CONCURRENCY_LIMIT);
   await (0, import_ai2.ensureAiStrategyPluginsLoaded)();
-  const filePath = await resolveDatasetFile();
-  const { rows, totalRows } = await (0, import_ai.readAiDatasetRows)({
-    filePath,
+  const filePaths = await resolveDatasetFiles();
+  const datasetId = getMergedGroupId(filePaths[0] || "")?.mergeId;
+  const { totalRows, selectedRows } = await (0, import_ai.countAiDatasetRows)({
+    filePaths,
     limitFromEnd: recent,
     skipFromEnd: skip
   });
-  if (!rows.length) {
+  const maxSelectedTimestamp = trailingPeriodMs == null ? null : await findMaxSelectedTimestamp({ filePaths, recent, skip });
+  const sinceTimestamp = trailingPeriodMs != null && maxSelectedTimestamp != null ? maxSelectedTimestamp - trailingPeriodMs : sinceInput;
+  const untilTimestamp = untilInput;
+  if (!selectedRows) {
     console.log(
       import_chalk.default.yellow(
-        `No AI prompt rows selected in ${filePath} (recent=${recent || "all"}, skip=${skip})`
+        `No AI prompt rows selected in ${filePaths.join(", ")} (recent=${recent || "all"}, skip=${skip})`
       )
     );
     process.exit(0);
   }
-  const strategyName = rows[0]?.strategyName || deriveStrategyNameFromFile(filePath);
-  const preparedRows = rows.map((row) => {
-    const { promptPair, signal } = resolvePromptRunContext(row);
-    const payload = (0, import_ai2.buildAiPayload)(signal);
-    return {
-      row,
-      promptPair,
-      payload,
-      signal,
-      deterministic: resolveDeterministicGateEvaluation(signal, row.direction)
-    };
-  });
-  const concurrency = Math.max(1, Math.min(parallel, rows.length));
+  let strategyName = deriveStrategyNameFromFile(filePaths[0] || "");
+  let strategyNameResolvedFromRow = false;
+  const concurrency = Math.max(1, Math.min(parallel, selectedRows));
   const bar = jsonOutput ? null : new import_progress.default(":current/:total [:bar][:percent] :symbol :status", {
-    total: rows.length,
+    total: selectedRows,
     width: 20
   });
   let failed = 0;
+  let scanned = 0;
+  let dateSkipped = 0;
   const errorMessages = [];
   const evaluations = [];
-  await (0, import_async.runWithConcurrency)(preparedRows, concurrency, async (preparedRow) => {
-    const { row, promptPair, payload, signal, deterministic } = preparedRow;
+  const evaluatedRows = [];
+  const duplicateSignalRows = [];
+  const deterministicEvaluations = [];
+  const activeTasks = /* @__PURE__ */ new Set();
+  const processRow = async (row, sequence) => {
+    const { promptPair, signal } = resolvePromptRunContext(row);
+    const payload = (0, import_ai2.buildAiPayload)(signal);
+    const deterministic = resolveDeterministicGateEvaluation(
+      signal,
+      row.direction
+    );
     const profit = Number(row.profit);
     const profitableTrade = isProfitableTrade(row);
+    deterministicEvaluations.push(deterministic);
     try {
       const analysis = localOnly ? await (0, import_ai2.runAiPromptLocal)(signal, { payload }) : await (0, import_ai2.runAiPrompt)(
         promptPair,
@@ -2069,16 +3372,54 @@ var main = async () => {
       );
       const aiApproved = isAiApproval(row, analysis, minQuality);
       const quality = normalizeQuality(analysis);
+      const timestamp = Number.isFinite(Number(row.timestamp)) ? Number(row.timestamp) : null;
+      const modelDirection = typeof analysis.direction === "string" && analysis.direction.trim() ? analysis.direction : null;
+      const rejectReason = typeof analysis.rejectReason === "string" && analysis.rejectReason ? String(analysis.rejectReason) : null;
+      const modelDirectionMatches = modelDirection === row.direction;
       const isCorrect = aiApproved === profitableTrade;
+      const features = buildAiTrainEvaluationFeatureSnapshot({
+        additionalIndicators: payload.additionalIndicators,
+        mode: dumpFeatureMode
+      });
       evaluations.push({
+        signalId: row.signalId,
         profit,
         profitableTrade,
         aiApproved,
+        rawAiApproved: aiApproved,
         quality,
         direction: row.direction,
-        timestamp: Number.isFinite(Number(row.timestamp)) ? Number(row.timestamp) : null,
-        modelCandidate: deterministic.modelCandidate
+        modelDirection,
+        modelDirectionMatches,
+        timestamp,
+        modelCandidate: deterministic.modelCandidate,
+        strategy: row.strategyName,
+        symbol: row.symbol,
+        testName: row.testName?.trim() || "",
+        configId: row.configId?.trim() || "",
+        rejectReason,
+        sequence,
+        ...features ? { features } : {}
       });
+      if (saveChart) {
+        evaluatedRows.push({
+          signalId: row.signalId,
+          symbol: row.symbol,
+          testName: row.testName?.trim() || "",
+          configId: row.configId?.trim() || "",
+          modelDirection,
+          profit,
+          profitableTrade,
+          aiApproved,
+          quality,
+          direction: row.direction,
+          timestamp,
+          strategy: row.strategyName,
+          rawAiApproved: aiApproved,
+          sequence,
+          tradeResult: row.tradeResult
+        });
+      }
       bar?.tick(1, {
         symbol: import_chalk.default.gray(row.symbol),
         status: isCorrect ? import_chalk.default.green("ok") : import_chalk.default.red("miss")
@@ -2095,43 +3436,183 @@ var main = async () => {
         status: import_chalk.default.yellow("error")
       });
     }
+  };
+  await (0, import_ai.streamAiDatasetRows)({
+    filePaths,
+    limitFromEnd: recent,
+    skipFromEnd: skip,
+    onRow: async (row) => {
+      scanned += 1;
+      if (!strategyNameResolvedFromRow && typeof row.strategyName === "string" && row.strategyName.trim()) {
+        strategyName = row.strategyName.trim();
+        strategyNameResolvedFromRow = true;
+      }
+      const timestamp = getDatasetRowTimestamp(row);
+      if (sinceTimestamp != null && (timestamp == null || timestamp < sinceTimestamp) || untilTimestamp != null && (timestamp == null || timestamp > untilTimestamp)) {
+        dateSkipped += 1;
+        bar?.tick(1, {
+          symbol: import_chalk.default.gray(row.symbol),
+          status: import_chalk.default.gray("date-skip")
+        });
+        return;
+      }
+      duplicateSignalRows.push(row);
+      const task = processRow(row, duplicateSignalRows.length - 1).finally(
+        () => {
+          activeTasks.delete(task);
+        }
+      );
+      activeTasks.add(task);
+      if (activeTasks.size >= concurrency) {
+        await Promise.race(activeTasks);
+      }
+    }
+  });
+  await Promise.all(activeTasks);
+  const quarantine = applyAiTrainSymbolQuarantine(evaluations, {
+    enabled: symbolQuarantineEnabled,
+    minApprovedLosses: symbolQuarantineMinLosses,
+    minProfitFactor: symbolQuarantineMinProfitFactor,
+    cooldownDays: symbolQuarantineDays
   });
-  const summary = summarizeAiTrainEvaluations(evaluations);
-  const directionSummaries = summarizeAiTrainEvaluationsByDirection(evaluations);
+  const finalEvaluations = quarantine.evaluations;
+  const duplicateSummary = summarizeAiTrainDuplicateSignals(duplicateSignalRows);
+  if (saveChart && symbolQuarantineEnabled) {
+    const approvalByKey = new Map(
+      finalEvaluations.map((evaluation) => [
+        evaluation.sequence,
+        evaluation.aiApproved
+      ])
+    );
+    for (const row of evaluatedRows) {
+      if (row.sequence != null) {
+        row.aiApproved = approvalByKey.get(row.sequence) ?? row.aiApproved;
+      }
+    }
+  }
+  const summary = summarizeAiTrainEvaluations(finalEvaluations);
+  const directionSummaries = summarizeAiTrainEvaluationsByDirection(finalEvaluations);
+  const monthlySummaries = summarizeAiTrainEvaluationsByMonth(finalEvaluations);
+  const qualityThresholdSummaries = summarizeAiTrainEvaluationsByQualityThreshold(
+    finalEvaluations,
+    qualityThresholds
+  );
   const deterministicSummary = summarizeDeterministicGateEvaluations(
-    preparedRows.map((preparedRow) => preparedRow.deterministic),
-    evaluations
+    deterministicEvaluations,
+    finalEvaluations.map((evaluation) => ({
+      aiApproved: evaluation.rawAiApproved ?? evaluation.aiApproved,
+      modelCandidate: evaluation.modelCandidate
+    }))
+  );
+  const coverage = summarizeAiTrainCoverage(finalEvaluations);
+  const terminalWindows = summarizeAiTrainTerminalWindows(
+    finalEvaluations,
+    terminalWindowDays
   );
+  const topRejectReasons = summarizeAiTrainRejectReasons(finalEvaluations);
+  const lineage = await buildAiTrainLineage({
+    projectRoot: String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
+    strategyName,
+    configIds: finalEvaluations.map((evaluation) => evaluation.configId),
+    runContext: {
+      mode: localOnly ? "local-deterministic" : "llm",
+      model: localOnly ? "local-deterministic" : model,
+      minQuality
+    }
+  });
   const evaluated = summary.correct + summary.incorrect;
   const result = {
     run: {
       strategy: strategyName,
-      filePath,
-      selected: rows.length,
+      datasetId: datasetId ?? null,
+      shardCount: filePaths.length,
+      filePath: filePaths.join(","),
+      selected: finalEvaluations.length,
       sourceRows: totalRows,
+      scanned,
+      dateSkipped,
       recent,
       skip,
+      since: sinceTimestamp,
+      until: untilTimestamp,
+      period: periodLabel,
       minQuality,
       mode: localOnly ? "local-deterministic" : "llm",
       model: localOnly ? "local-deterministic" : model,
-      parallel: concurrency
+      parallel: concurrency,
+      dumpFeatures: dumpFeatureMode,
+      terminalWindows: terminalWindowDays
     },
     outcome: summary,
     byDirection: directionSummaries,
+    monthly: monthlySummaries,
+    qualityThresholds: qualityThresholdSummaries,
     deterministicFlow: deterministicSummary,
     qualityBreakdown: summary.qualityBuckets,
+    symbolQuarantine: quarantine.summary,
+    duplicates: duplicateSummary,
+    research: {
+      coverage,
+      terminalWindows,
+      topRejectReasons,
+      lineage
+    },
     errors: {
       failed,
       providerErrors: errorMessages
     }
   };
+  if (dumpEvaluationsPath) {
+    await import_promises2.default.mkdir(import_path.default.dirname(import_path.default.resolve(dumpEvaluationsPath)), {
+      recursive: true
+    });
+    await import_promises2.default.writeFile(
+      dumpEvaluationsPath,
+      finalEvaluations.map(
+        (evaluation) => JSON.stringify({
+          signalId: evaluation.signalId,
+          strategy: evaluation.strategy,
+          symbol: evaluation.symbol,
+          direction: evaluation.direction,
+          modelDirection: evaluation.modelDirection,
+          modelDirectionMatches: evaluation.modelDirectionMatches,
+          timestamp: evaluation.timestamp,
+          testName: evaluation.testName,
+          configId: evaluation.configId,
+          profit: evaluation.profit,
+          profitableTrade: evaluation.profitableTrade,
+          aiApproved: evaluation.aiApproved,
+          rawAiApproved: evaluation.rawAiApproved,
+          quality: evaluation.quality,
+          modelCandidate: evaluation.modelCandidate,
+          rejectReason: evaluation.rejectReason,
+          sequence: evaluation.sequence,
+          ...evaluation.features ? { features: evaluation.features } : {}
+        })
+      ).join("\n") + (finalEvaluations.length ? "\n" : ""),
+      "utf8"
+    );
+  }
+  if (saveChart) {
+    await persistAiChartSnapshot({
+      strategyName,
+      evaluatedRows,
+      minQuality,
+      model: localOnly ? "local-deterministic" : model,
+      mode: localOnly ? "local-deterministic" : "llm",
+      userName,
+      datasetId
+    });
+  }
   if (jsonOutput) {
     console.log(JSON.stringify(result));
-    process.exit(failed === rows.length ? 1 : 0);
+    process.exit(failed === selectedRows ? 1 : 0);
   }
   console.log("");
   console.log(import_chalk.default.green("AI train finished"));
-  console.log(import_chalk.default.gray(filePath));
+  filePaths.forEach((filePath) => {
+    console.log(import_chalk.default.gray(filePath));
+  });
   console.log("");
   printSection(
     "RUN",
@@ -2139,17 +3620,69 @@ var main = async () => {
       [import_chalk.default.gray("FIELD"), import_chalk.default.gray("VALUE")],
       [
         ["strategy", import_chalk.default.yellow(strategyName)],
-        ["selected", import_chalk.default.blue(String(rows.length))],
+        ["dataset_id", import_chalk.default.gray(datasetId ?? "n/a")],
+        ["dataset_shards", import_chalk.default.blue(String(filePaths.length))],
+        ["selected", import_chalk.default.blue(String(finalEvaluations.length))],
         ["source_rows", import_chalk.default.blue(String(totalRows))],
+        ["scanned", import_chalk.default.blue(String(scanned))],
+        ["date_skipped", import_chalk.default.blue(String(dateSkipped))],
         ["recent", import_chalk.default.blue(recent === 0 ? "all" : String(recent))],
         ["skip", import_chalk.default.blue(String(skip))],
+        [
+          "since",
+          sinceTimestamp == null ? import_chalk.default.gray("n/a") : import_chalk.default.gray(new Date(sinceTimestamp).toISOString())
+        ],
+        [
+          "until",
+          untilTimestamp == null ? import_chalk.default.gray("n/a") : import_chalk.default.gray(new Date(untilTimestamp).toISOString())
+        ],
+        [
+          "period",
+          periodLabel == null ? import_chalk.default.gray("n/a") : import_chalk.default.gray(periodLabel)
+        ],
         ["min_quality", import_chalk.default.magenta(String(minQuality))],
         [
           "mode",
           localOnly ? import_chalk.default.green("local-deterministic") : import_chalk.default.yellow("llm")
         ],
         ["model", import_chalk.default.yellow(localOnly ? "local-deterministic" : model)],
-        ["parallel", import_chalk.default.magenta(String(concurrency))]
+        ["parallel", import_chalk.default.magenta(String(concurrency))],
+        [
+          "terminal_windows",
+          terminalWindowDays.length ? import_chalk.default.gray(terminalWindowDays.map((days) => `${days}d`).join(",")) : import_chalk.default.gray("off")
+        ],
+        [
+          "dataset_min_timestamp",
+          coverage.minTimestamp == null ? import_chalk.default.gray("n/a") : import_chalk.default.gray(new Date(coverage.minTimestamp).toISOString())
+        ],
+        [
+          "dataset_max_timestamp",
+          coverage.maxTimestamp == null ? import_chalk.default.gray("n/a") : import_chalk.default.gray(new Date(coverage.maxTimestamp).toISOString())
+        ],
+        [
+          "dataset_lag_days",
+          coverage.dataLagDays == null ? import_chalk.default.gray("n/a") : import_chalk.default.yellow(coverage.dataLagDays.toFixed(2))
+        ],
+        ["git_sha", import_chalk.default.gray(lineage.gitSha ?? "n/a")],
+        [
+          "git_dirty",
+          lineage.gitDirty == null ? import_chalk.default.gray("n/a") : lineage.gitDirty ? import_chalk.default.yellow("true") : import_chalk.default.green("false")
+        ],
+        ["gate_fingerprint", import_chalk.default.gray(lineage.gateFingerprint)],
+        ["config_ids_fingerprint", import_chalk.default.gray(lineage.configIdsFingerprint)],
+        ["context_fingerprint", import_chalk.default.gray(lineage.contextFingerprint)],
+        [
+          "symbol_quarantine",
+          symbolQuarantineEnabled ? import_chalk.default.green("enabled") : import_chalk.default.gray("off")
+        ],
+        [
+          "dump_evaluations",
+          dumpEvaluationsPath ? import_chalk.default.gray(dumpEvaluationsPath) : import_chalk.default.gray("off")
+        ],
+        [
+          "dump_features",
+          dumpFeatureMode === "none" ? import_chalk.default.gray("off") : import_chalk.default.gray(dumpFeatureMode)
+        ]
       ]
     )
   );
@@ -2195,6 +3728,55 @@ var main = async () => {
       ]
     )
   );
+  if (terminalWindows.length) {
+    printSection(
+      "TERMINAL WINDOWS (ANCHORED TO DATASET MAX)",
+      createTable(
+        [
+          import_chalk.default.gray("WINDOW"),
+          import_chalk.default.gray("COVERAGE"),
+          import_chalk.default.gray("FROM"),
+          import_chalk.default.gray("TO"),
+          import_chalk.default.gray("EVAL"),
+          import_chalk.default.gray("APPROVED"),
+          import_chalk.default.gray("CALENDAR/D"),
+          import_chalk.default.gray("WR"),
+          import_chalk.default.gray("PF"),
+          import_chalk.default.gray("PNL"),
+          import_chalk.default.gray("MAX_DD"),
+          import_chalk.default.gray("TOP REJECT")
+        ],
+        terminalWindows.map((window2) => [
+          import_chalk.default.yellow(window2.label),
+          window2.complete ? import_chalk.default.green("full") : import_chalk.default.yellow("partial"),
+          import_chalk.default.gray(new Date(window2.since).toISOString()),
+          import_chalk.default.gray(new Date(window2.until).toISOString()),
+          import_chalk.default.blue(String(window2.selected)),
+          import_chalk.default.cyan(String(window2.outcome.approved)),
+          colorizeMetricNumber(window2.approvedPerCalendarDay),
+          colorizeRatio(window2.outcome.approvedRisk.winRate),
+          colorizeMetricNumber(window2.outcome.approvedRisk.profitFactor),
+          colorizeProfit(window2.outcome.approvedRisk.totalProfit),
+          colorizeProfit(-window2.outcome.approvedRisk.maxDrawdown),
+          import_chalk.default.gray(
+            window2.topRejectReasons[0] ? `${window2.topRejectReasons[0].reason} (${window2.topRejectReasons[0].count})` : "n/a"
+          )
+        ])
+      )
+    );
+  }
+  if (topRejectReasons.length) {
+    printSection(
+      "TOP REJECT REASONS",
+      createTable(
+        [import_chalk.default.gray("REASON"), import_chalk.default.gray("COUNT")],
+        topRejectReasons.map(({ reason, count }) => [
+          import_chalk.default.yellow(reason),
+          import_chalk.default.blue(String(count))
+        ])
+      )
+    );
+  }
   printSection(
     "CONFUSION",
     createTable(
@@ -2209,6 +3791,56 @@ var main = async () => {
       ]
     )
   );
+  printSection(
+    "APPROVED RISK",
+    createTable(
+      [import_chalk.default.gray("METRIC"), import_chalk.default.gray("VALUE")],
+      [
+        ["trades", import_chalk.default.cyan(String(summary.approvedRisk.trades))],
+        ["total_profit", colorizeProfit(summary.approvedRisk.totalProfit)],
+        ["gross_profit", colorizeProfit(summary.approvedRisk.grossProfit)],
+        ["gross_loss", colorizeProfit(-summary.approvedRisk.grossLoss)],
+        [
+          "profit_factor",
+          colorizeMetricNumber(summary.approvedRisk.profitFactor)
+        ],
+        [
+          "payoff_ratio",
+          colorizeMetricNumber(summary.approvedRisk.payoffRatio)
+        ],
+        ["avg_win", colorizeProfit(summary.approvedRisk.avgWin)],
+        [
+          "avg_loss",
+          summary.approvedRisk.avgLoss == null ? import_chalk.default.gray("n/a") : colorizeProfit(-summary.approvedRisk.avgLoss)
+        ],
+        ["largest_win", colorizeProfit(summary.approvedRisk.largestWin)],
+        ["largest_loss", colorizeProfit(summary.approvedRisk.largestLoss)],
+        ["win_rate", colorizeRatio(summary.approvedRisk.winRate)],
+        ["max_drawdown", colorizeProfit(-summary.approvedRisk.maxDrawdown)],
+        [
+          "max_drawdown_pct_of_gross_profit",
+          colorizeRatio(summary.approvedRisk.maxDrawdownPctOfGrossProfit)
+        ],
+        [
+          "max_drawdown_pct_of_total_profit",
+          colorizeRatio(summary.approvedRisk.maxDrawdownPctOfTotalProfit)
+        ],
+        [
+          "recovery_factor",
+          colorizeMetricNumber(summary.approvedRisk.recoveryFactor)
+        ],
+        ["ulcer_index", colorizeMetricNumber(summary.approvedRisk.ulcerIndex)],
+        [
+          "max_consecutive_wins",
+          import_chalk.default.green(String(summary.approvedRisk.maxConsecutiveWins))
+        ],
+        [
+          "max_consecutive_losses",
+          import_chalk.default.red(String(summary.approvedRisk.maxConsecutiveLosses))
+        ]
+      ]
+    )
+  );
   if (directionSummaries.length) {
     printSection(
       "BY DIRECTION",
@@ -2218,6 +3850,11 @@ var main = async () => {
           import_chalk.default.gray("EVAL"),
           import_chalk.default.gray("ACCURACY"),
           import_chalk.default.gray("APPROVED"),
+          import_chalk.default.gray("CADENCE/D"),
+          import_chalk.default.gray("WR"),
+          import_chalk.default.gray("PF"),
+          import_chalk.default.gray("PNL"),
+          import_chalk.default.gray("MAX_DD"),
           import_chalk.default.green("TP"),
           import_chalk.default.red("FP"),
           import_chalk.default.green("TN"),
@@ -2232,6 +3869,11 @@ var main = async () => {
             import_chalk.default.blue(String(directionEvaluated)),
             colorizePercent(directionSummary.correct, directionEvaluated),
             import_chalk.default.cyan(String(directionSummary.approved)),
+            colorizeMetricNumber(directionSummary.avgApprovedTradesPerDay),
+            colorizeRatio(directionSummary.approvedRisk.winRate),
+            colorizeMetricNumber(directionSummary.approvedRisk.profitFactor),
+            colorizeProfit(directionSummary.approvedRisk.totalProfit),
+            colorizeProfit(-directionSummary.approvedRisk.maxDrawdown),
             import_chalk.default.green(String(directionSummary.truePositive)),
             import_chalk.default.red(String(directionSummary.falsePositive)),
             import_chalk.default.green(String(directionSummary.trueNegative)),
@@ -2243,6 +3885,69 @@ var main = async () => {
       )
     );
   }
+  if (qualityThresholdSummaries.length) {
+    printSection(
+      "QUALITY THRESHOLDS",
+      createTable(
+        [
+          import_chalk.default.gray("BUCKET"),
+          import_chalk.default.gray("APPROVED"),
+          import_chalk.default.gray("CADENCE/D"),
+          import_chalk.default.gray("WR"),
+          import_chalk.default.gray("PF"),
+          import_chalk.default.gray("PNL"),
+          import_chalk.default.gray("MAX_DD")
+        ],
+        qualityThresholdSummaries.map(
+          ({ label, summary: thresholdSummary }) => [
+            import_chalk.default.yellow(label),
+            import_chalk.default.cyan(String(thresholdSummary.approved)),
+            colorizeMetricNumber(thresholdSummary.avgApprovedTradesPerDay),
+            colorizeRatio(thresholdSummary.approvedRisk.winRate),
+            colorizeMetricNumber(thresholdSummary.approvedRisk.profitFactor),
+            colorizeProfit(thresholdSummary.approvedRisk.totalProfit),
+            colorizeProfit(-thresholdSummary.approvedRisk.maxDrawdown)
+          ]
+        )
+      )
+    );
+  }
+  if (monthlySummaries.length) {
+    const losingMonths = monthlySummaries.filter(
+      ({ summary: monthSummary }) => monthSummary.approvedRisk.totalProfit < 0
+    ).length;
+    printSection(
+      "MONTHLY STABILITY",
+      createTable(
+        [
+          import_chalk.default.gray("MONTH"),
+          import_chalk.default.gray("APPROVED"),
+          import_chalk.default.gray("WR"),
+          import_chalk.default.gray("PF"),
+          import_chalk.default.gray("PNL"),
+          import_chalk.default.gray("MAX_DD")
+        ],
+        [
+          [
+            import_chalk.default.yellow("losing_months"),
+            import_chalk.default.cyan(`${losingMonths}/${monthlySummaries.length}`),
+            import_chalk.default.gray(""),
+            import_chalk.default.gray(""),
+            import_chalk.default.gray(""),
+            import_chalk.default.gray("")
+          ],
+          ...monthlySummaries.map(({ month, summary: monthSummary }) => [
+            import_chalk.default.yellow(month),
+            import_chalk.default.cyan(String(monthSummary.approved)),
+            colorizeRatio(monthSummary.approvedRisk.winRate),
+            colorizeMetricNumber(monthSummary.approvedRisk.profitFactor),
+            colorizeProfit(monthSummary.approvedRisk.totalProfit),
+            colorizeProfit(-monthSummary.approvedRisk.maxDrawdown)
+          ])
+        ]
+      )
+    );
+  }
   printSection(
     "DETERMINISTIC FLOW",
     createTable(
@@ -2284,6 +3989,82 @@ var main = async () => {
       ]
     )
   );
+  printSection(
+    "SYMBOL QUARANTINE",
+    createTable(
+      [import_chalk.default.gray("FIELD"), import_chalk.default.gray("VALUE")],
+      [
+        [
+          "enabled",
+          quarantine.summary.enabled ? import_chalk.default.green("true") : import_chalk.default.gray("false")
+        ],
+        [
+          "min_approved_losses",
+          import_chalk.default.cyan(String(quarantine.summary.minApprovedLosses))
+        ],
+        [
+          "min_profit_factor",
+          import_chalk.default.cyan(String(quarantine.summary.minProfitFactor))
+        ],
+        ["cooldown_days", import_chalk.default.cyan(String(quarantine.summary.cooldownDays))],
+        ["blocked", import_chalk.default.yellow(String(quarantine.summary.blocked))],
+        ["events", import_chalk.default.yellow(String(quarantine.summary.events.length))]
+      ]
+    )
+  );
+  if (quarantine.summary.events.length) {
+    printSection(
+      "SYMBOL QUARANTINE EVENTS",
+      createTable(
+        [
+          import_chalk.default.gray("SYMBOL"),
+          import_chalk.default.gray("STARTED"),
+          import_chalk.default.gray("UNTIL"),
+          import_chalk.default.gray("LOSSES"),
+          import_chalk.default.gray("PF")
+        ],
+        quarantine.summary.events.slice(0, 20).map((event) => [
+          import_chalk.default.yellow(event.symbol),
+          import_chalk.default.gray(new Date(event.startedAt).toISOString()),
+          import_chalk.default.gray(new Date(event.until).toISOString()),
+          import_chalk.default.red(String(event.approvedLosses)),
+          colorizeMetricNumber(event.profitFactor)
+        ])
+      )
+    );
+  }
+  printSection(
+    "DUPLICATE SIGNALS",
+    createTable(
+      [import_chalk.default.gray("FIELD"), import_chalk.default.gray("VALUE")],
+      [
+        ["groups", import_chalk.default.yellow(String(duplicateSummary.groups))],
+        ["rows", import_chalk.default.yellow(String(duplicateSummary.rows))],
+        ["max_group_size", import_chalk.default.yellow(String(duplicateSummary.maxGroupSize))]
+      ]
+    )
+  );
+  if (duplicateSummary.worstGroups.length) {
+    printSection(
+      "WORST DUPLICATE GROUPS",
+      createTable(
+        [
+          import_chalk.default.gray("SYMBOL"),
+          import_chalk.default.gray("DIR"),
+          import_chalk.default.gray("TIME"),
+          import_chalk.default.gray("COUNT"),
+          import_chalk.default.gray("TOTAL_PROFIT")
+        ],
+        duplicateSummary.worstGroups.map((group) => [
+          import_chalk.default.yellow(group.symbol),
+          import_chalk.default.gray(group.direction),
+          import_chalk.default.gray(new Date(group.timestamp).toISOString()),
+          import_chalk.default.cyan(String(group.count)),
+          colorizeProfit(group.totalProfit)
+        ])
+      )
+    );
+  }
   if (summary.qualityBuckets.length) {
     printSection(
       "QUALITY BREAKDOWN",
@@ -2291,18 +4072,16 @@ var main = async () => {
         [
           import_chalk.default.gray("QUALITY"),
           import_chalk.default.gray("COUNT"),
-          import_chalk.default.gray("APPROVED"),
-          import_chalk.default.gray("APPROVAL_RATE"),
           import_chalk.default.gray("WINRATE"),
-          import_chalk.default.gray("AVG_PROFIT")
+          import_chalk.default.gray("AVG_PROFIT"),
+          import_chalk.default.gray("TOTAL_PROFIT")
         ],
         summary.qualityBuckets.map((bucket) => [
           colorizeQuality(bucket.quality),
           import_chalk.default.blue(String(bucket.count)),
-          import_chalk.default.cyan(String(bucket.approved)),
-          colorizeRatio(bucket.approved / bucket.count),
           colorizeRatio(bucket.profitable / bucket.count),
-          colorizeProfit(bucket.totalProfit / bucket.count)
+          colorizeProfit(bucket.totalProfit / bucket.count),
+          colorizeProfit(bucket.totalProfit)
         ])
       )
     );
@@ -2313,9 +4092,9 @@ var main = async () => {
       console.log(import_chalk.default.yellow(`- ${message}`));
     });
   }
-  process.exit(failed === rows.length ? 1 : 0);
+  process.exit(failed === selectedRows ? 1 : 0);
 };
-main().catch((error) => {
-  console.error(import_chalk.default.red(error?.message || String(error)));
-  process.exit(1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
 });