@tradejs/cli 1.0.9 → 1.0.11

package/dist/lib/aiTrainDataset.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/aiTrainDataset.ts
+var aiTrainDataset_exports = {};
+__export(aiTrainDataset_exports, {
+  extractSignalFromAiDatasetRow: () => extractSignalFromAiDatasetRow
+});
+module.exports = __toCommonJS(aiTrainDataset_exports);
+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
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractSignalFromAiDatasetRow
+});

package/dist/lib/aiTrainEvaluationDump.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/aiTrainEvaluationDump.ts
+var aiTrainEvaluationDump_exports = {};
+__export(aiTrainEvaluationDump_exports, {
+  buildAiTrainEvaluationFeatureSnapshot: () => buildAiTrainEvaluationFeatureSnapshot
+});
+module.exports = __toCommonJS(aiTrainEvaluationDump_exports);
+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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAiTrainEvaluationFeatureSnapshot
+});

package/dist/lib/aiTrainMetrics.js

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var aiTrainMetrics_exports = {};
 __export(aiTrainMetrics_exports, {
   summarizeAiTrainEvaluations: () => summarizeAiTrainEvaluations,
-  summarizeAiTrainEvaluationsByDirection: () => summarizeAiTrainEvaluationsByDirection
+  summarizeAiTrainEvaluationsByDirection: () => summarizeAiTrainEvaluationsByDirection,
+  summarizeAiTrainEvaluationsByMonth: () => summarizeAiTrainEvaluationsByMonth,
+  summarizeAiTrainEvaluationsByQualityThreshold: () => summarizeAiTrainEvaluationsByQualityThreshold
 });
 module.exports = __toCommonJS(aiTrainMetrics_exports);
 var divideOrNull = (num, denom) => {
@@ -34,17 +36,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;
@@ -137,6 +241,7 @@ var summarizeAiTrainEvaluations = (evaluations) => {
     avgApprovedTradesPerDay,
     avgApprovedTradesPerWeek,
     expectancyDelta,
+    approvedRisk: summarizeApprovedRisk(evaluations),
     qualityBuckets: [...bucketMap.values()].sort(
       (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
     )
@@ -151,6 +256,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) {
@@ -166,8 +281,33 @@ 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)
+    }))
+  )
+}));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   summarizeAiTrainEvaluations,
-  summarizeAiTrainEvaluationsByDirection
+  summarizeAiTrainEvaluationsByDirection,
+  summarizeAiTrainEvaluationsByMonth,
+  summarizeAiTrainEvaluationsByQualityThreshold
 });

package/dist/lib/aiTrainOptions.js

@@ -0,0 +1,130 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/aiTrainOptions.ts
+var aiTrainOptions_exports = {};
+__export(aiTrainOptions_exports, {
+  hasCliOption: () => hasCliOption,
+  parseDumpFeatureMode: () => parseDumpFeatureMode,
+  parseQualityThresholds: () => parseQualityThresholds,
+  parseTerminalWindowDays: () => parseTerminalWindowDays,
+  parseTimestampFilter: () => parseTimestampFilter,
+  parseTrailingPeriodMs: () => parseTrailingPeriodMs,
+  resolveAiTrainRecentLimit: () => resolveAiTrainRecentLimit
+});
+module.exports = __toCommonJS(aiTrainOptions_exports);
+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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasCliOption,
+  parseDumpFeatureMode,
+  parseQualityThresholds,
+  parseTerminalWindowDays,
+  parseTimestampFilter,
+  parseTrailingPeriodMs,
+  resolveAiTrainRecentLimit
+});

package/dist/lib/aiTrainQuarantine.js

@@ -0,0 +1,199 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/aiTrainQuarantine.ts
+var aiTrainQuarantine_exports = {};
+__export(aiTrainQuarantine_exports, {
+  applyAiTrainSymbolQuarantine: () => applyAiTrainSymbolQuarantine,
+  summarizeAiTrainDuplicateSignals: () => summarizeAiTrainDuplicateSignals
+});
+module.exports = __toCommonJS(aiTrainQuarantine_exports);
+var import_crypto = require("crypto");
+var DAY_MS = 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_MS;
+  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)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyAiTrainSymbolQuarantine,
+  summarizeAiTrainDuplicateSignals
+});