@tradejs/node 3.1.28 → 3.1.29-beta.260

package/dist/chunk-ZZQLTUTP.mjs

@@ -0,0 +1,614 @@
+// src/jevTraining.ts
+import { JEV_DIMENSIONS as JEV_DIMENSIONS2, decideJev, predictJevTree } from "@tradejs/core/jev";
+import { jevHash, validateJevResponse } from "@tradejs/infra/jev";
+
+// src/jevInput.ts
+import { intervalToMs } from "@tradejs/core/data";
+import { JEV_DIMENSIONS } from "@tradejs/core/jev";
+var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var at = (value, ...path) => path.reduce((current, key) => object(current)[key], value);
+var finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var fact = (value) => {
+  if (value == null || typeof value === "boolean") return value ?? null;
+  if (typeof value === "number") return finite(value);
+  if (typeof value === "string" && value.length <= 60) return value;
+  throw new Error("Invalid Jev evidence fact");
+};
+var buildJevInput = (signal) => {
+  if (!["LONG", "SHORT"].includes(signal.direction ?? "") || !Number.isFinite(signal.timestamp))
+    throw new Error("Jev requires a dated directional signal");
+  const base = object(signal.additionalIndicators?.baseContext);
+  const baseTimestamp = at(base, "candle", "timestamp");
+  const baseKnownAt = finite(baseTimestamp);
+  const baseProblem = !Object.keys(base).length ? "no_base_context" : baseKnownAt == null ? "missing_timestamp" : baseKnownAt > signal.timestamp ? "future" : signal.timestamp - baseKnownAt > intervalToMs(signal.interval) ? "stale" : null;
+  const evidence = signal.jevEvidence;
+  const features = {};
+  const provenance = {};
+  const missing = {};
+  const put = (key, value, details, missingReason = "missing_value") => {
+    const normalized = fact(value);
+    if (normalized != null) {
+      features[key] = normalized;
+      provenance[key] = details;
+    } else {
+      missing[key] = missingReason;
+    }
+  };
+  const signalFact = {
+    knownAt: signal.timestamp,
+    scope: "target",
+    source: "signal"
+  };
+  put("signal.direction", signal.direction, signalFact);
+  const marketKeys = [
+    "market.trendBias",
+    "market.swingBias",
+    "market.volumeRel20",
+    "market.deltaPct",
+    "market.fastMaDistanceAtr"
+  ];
+  if (baseProblem) {
+    for (const key of marketKeys) missing[key] = baseProblem;
+  } else {
+    const marketFact = {
+      knownAt: baseKnownAt,
+      scope: "target",
+      source: "baseContext"
+    };
+    put("market.trendBias", at(base, "regime", "trend", "bias"), marketFact);
+    put("market.swingBias", at(base, "structure", "swing", "bias"), marketFact);
+    put(
+      "market.volumeRel20",
+      at(base, "participation", "volume", "volumeRel20"),
+      { ...marketFact, unit: "ratio" }
+    );
+    const deltaSource = at(base, "participation", "delta", "source");
+    put(
+      "market.deltaPct",
+      at(base, "participation", "delta", "deltaPct"),
+      {
+        ...marketFact,
+        source: typeof deltaSource === "string" ? `baseContext.participation.delta.${deltaSource}` : "baseContext.participation.delta",
+        unit: "ratio"
+      },
+      deltaSource === "ohlcv_proxy" ? "ohlcv_proxy_no_taker_volume" : "missing_value"
+    );
+    put(
+      "market.fastMaDistanceAtr",
+      at(base, "regime", "trend", "priceDistanceToMaFastAtr"),
+      { ...marketFact, unit: "ATR" }
+    );
+  }
+  const price = finite(signal.prices.currentPrice);
+  const stop = finite(signal.prices.stopLossPrice);
+  const target = finite(signal.prices.takeProfitPrice);
+  const atr = baseProblem ? null : finite(at(base, "raw", "volatility", "atr"));
+  if (price == null || stop == null || target == null)
+    throw new Error("Invalid Jev signal prices");
+  put(
+    "signal.validLevels",
+    signal.direction === "LONG" ? stop < price && price < target : target < price && price < stop,
+    signalFact
+  );
+  if (atr != null && atr > 0) {
+    put("signal.stopDistanceAtr", Math.abs(price - stop) / atr, {
+      ...signalFact,
+      unit: "ATR"
+    });
+    put("signal.targetDistanceAtr", Math.abs(price - target) / atr, {
+      ...signalFact,
+      unit: "ATR"
+    });
+  } else {
+    missing["signal.stopDistanceAtr"] = baseProblem ?? "missing_atr";
+    missing["signal.targetDistanceAtr"] = baseProblem ?? "missing_atr";
+  }
+  let geometryStatus = "absent";
+  const figures = signal.figures;
+  const groups = [figures?.lines, figures?.points, figures?.zones];
+  const points = [
+    ...figures?.trendLine?.points ?? [],
+    ...figures?.trendLine?.touches ?? [],
+    ...groups.flatMap(
+      (group) => Array.isArray(group) ? group.flatMap(
+        (item) => "points" in item ? item.points : "start" in item ? [item.start, item.end] : []
+      ) : []
+    )
+  ];
+  if (points.length > 128 || groups.some(
+    (group) => group && (!Array.isArray(group) || group.length > 24)
+  ) || points.some(
+    (point) => !Number.isFinite(point.timestamp) || !Number.isFinite(point.value) || point.timestamp > signal.timestamp || object(point).knownAt != null && (!Number.isFinite(object(point).knownAt) || Number(object(point).knownAt) > signal.timestamp)
+  ))
+    geometryStatus = "invalid";
+  else if (points.length) geometryStatus = "available";
+  if (evidence) {
+    if (typeof evidence !== "object" || Array.isArray(evidence) || !evidence.facts || typeof evidence.facts !== "object" || Array.isArray(evidence.facts) || evidence.geometry != null && (typeof evidence.geometry !== "object" || Array.isArray(evidence.geometry)))
+      throw new Error("Invalid Jev evidence");
+    if (!/^[a-zA-Z0-9._-]{1,40}$/.test(evidence.version) || !Number.isFinite(evidence.knownAt) || evidence.knownAt > signal.timestamp || Object.keys(evidence.facts ?? {}).length > 16 || Object.keys(evidence.geometry ?? {}).length > 16)
+      throw new Error("Invalid or oversized Jev evidence");
+    const strategyFact = {
+      knownAt: evidence.knownAt,
+      scope: "strategy",
+      source: "strategy.jevEvidence"
+    };
+    const detailFor = (key) => {
+      const detail = evidence.factDetails?.[key] ?? strategyFact;
+      if (!Number.isFinite(detail.knownAt) || detail.knownAt > signal.timestamp || !["target", "strategy"].includes(detail.scope) || detail.unit != null && !/^[a-zA-Z0-9%._/-]{1,20}$/.test(detail.unit) || detail.source != null && !/^[a-zA-Z0-9._/-]{1,60}$/.test(detail.source))
+        throw new Error("Invalid Jev fact provenance");
+      return { ...strategyFact, ...detail };
+    };
+    put("setup.version", evidence.version, strategyFact);
+    for (const [key, value] of Object.entries(evidence.facts)) {
+      if (!/^[a-zA-Z][a-zA-Z0-9_]{0,39}$/.test(key) || /^(?:profit|pnl|outcome|label|score|scores|quality|verdict|approval|decision|result)$/i.test(
+        key
+      ))
+        throw new Error("Invalid Jev evidence key");
+      put(`setup.${key}`, value, detailFor(`setup.${key}`));
+    }
+    for (const [key, value] of Object.entries(evidence.geometry ?? {})) {
+      if (!/^[a-zA-Z][a-zA-Z0-9_]{0,39}$/.test(key))
+        throw new Error("Invalid Jev geometry key");
+      put(`geometry.${key}`, value, detailFor(`geometry.${key}`));
+    }
+    if (Object.keys(evidence.factDetails ?? {}).some(
+      (key) => !(key in provenance)
+    ))
+      throw new Error("Jev provenance references an unavailable fact");
+  }
+  if (evidence?.geometry && Object.keys(evidence.geometry).length && geometryStatus === "absent")
+    geometryStatus = "facts_only";
+  if (geometryStatus === "absent") missing["geometry.figures"] = "no_geometry";
+  if (geometryStatus === "invalid")
+    missing["geometry.figures"] = "invalid_geometry";
+  if (Object.keys(features).length > 40 || JSON.stringify(features).length > 4e3)
+    throw new Error("Jev input exceeds the microdecision budget");
+  const has = (key) => key in features;
+  const setupKeys = Object.keys(features).filter(
+    (key) => key.startsWith("setup.")
+  );
+  const questions = JEV_DIMENSIONS.filter((dimension) => {
+    switch (dimension) {
+      case "trend":
+        return has("market.trendBias");
+      case "swing":
+        return has("market.swingBias");
+      case "participation":
+        return has("market.volumeRel20") || has("market.deltaPct");
+      case "setupParticipation":
+        return setupKeys.some(
+          (key) => /volume|delta|flow|liquidity|turnover/i.test(key)
+        );
+      case "extension":
+        return has("market.fastMaDistanceAtr") || has("setup.breakoutDistanceAtr") || has("signal.stopDistanceAtr");
+      case "confirmation":
+        return setupKeys.some(
+          (key) => /stage|confirm|retest|accept/i.test(key)
+        );
+      case "setupStrength":
+        return setupKeys.some(
+          (key) => key !== "setup.version" && !/volume|delta|flow|liquidity|turnover|stage|confirm|retest|accept|breakoutDistance/i.test(
+            key
+          )
+        );
+      case "geometry":
+        return geometryStatus !== "invalid" && Object.keys(features).some((key) => key.startsWith("geometry."));
+    }
+  });
+  return {
+    schema: "tradejs-jev-input/v4",
+    strategy: signal.strategy,
+    symbol: signal.symbol,
+    interval: String(signal.interval),
+    timestamp: signal.timestamp,
+    direction: signal.direction,
+    features,
+    provenance,
+    missing,
+    questions,
+    geometryStatus
+  };
+};
+var criteria = (subject) => [
+  `${subject} is clearly contradicted by the supplied facts.`,
+  `${subject} has a material conflict.`,
+  `${subject} is uncertain from the supplied facts.`,
+  `${subject} has adequate support.`,
+  `${subject} has strong support without a material conflict.`
+];
+var JEV_QUESTIONS = {
+  trend: {
+    type: "score",
+    instructions: "Does market.trendBias support signal.direction? Judge only the target-asset trend, not swings or setup quality.",
+    criteria: criteria("Target-asset trend alignment")
+  },
+  swing: {
+    type: "score",
+    instructions: "Does market.swingBias support signal.direction? Judge only the target-asset swing structure, not the broader trend.",
+    criteria: criteria("Target-asset swing alignment")
+  },
+  participation: {
+    type: "score",
+    instructions: "Does the supplied market.volumeRel20 or market.deltaPct show target-asset participation supportive of this direction? Ignore strategy setup volume and do not infer missing flow.",
+    criteria: criteria("Current target-asset participation")
+  },
+  setupParticipation: {
+    type: "score",
+    instructions: "Do the strategy-defined setup volume, flow or liquidity facts support the named setup? Use only relevant setup.* facts, not market.volumeRel20; do not infer missing data.",
+    criteria: criteria("Participation within the setup")
+  },
+  extension: {
+    type: "score",
+    instructions: "Do the supplied ATR-normalized entry-distance facts suggest the entry is not excessively extended? Use only distance facts; do not calculate new ratios or judge confirmation.",
+    criteria: criteria("Entry location without excessive extension")
+  },
+  confirmation: {
+    type: "score",
+    instructions: "Do the supplied setup stage and confirmation facts indicate a confirmed rather than premature entry? Do not judge distance or predict the outcome.",
+    criteria: criteria("Setup confirmation at entry")
+  },
+  setupStrength: {
+    type: "score",
+    instructions: "Do the strategy-defined setup strength and quality facts support this candidate? Exclude volume, confirmation, entry distance and geometry; do not assume missing facts.",
+    criteria: criteria("Non-geometric setup strength")
+  },
+  geometry: {
+    type: "score",
+    instructions: "Do the supplied geometry.* facts support the named setup? Do not infer unseen figure points or certify mathematical validity.",
+    criteria: criteria("Setup geometry")
+  }
+};
+var questionsForJevInput = (input) => Object.fromEntries(input.questions.map((key) => [key, JEV_QUESTIONS[key]]));
+var stateForJevInput = (input) => ({
+  schema: input.schema,
+  strategy: input.strategy,
+  direction: input.direction,
+  facts: input.features,
+  missing: input.missing,
+  geometryStatus: input.geometryStatus,
+  units: Object.fromEntries(
+    Object.entries(input.provenance).filter(([, detail]) => detail.unit != null).map(([key, detail]) => [key, detail.unit])
+  ),
+  sources: Object.fromEntries(
+    Object.entries(input.provenance).filter(([, detail]) => detail.source != null).map(([key, detail]) => [key, detail.source])
+  )
+});
+
+// src/jevTraining.ts
+var mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
+var variance = (values) => {
+  const average = mean(values);
+  return values.reduce((sum, value) => sum + (value - average) ** 2, 0);
+};
+var validateJevStudy = (rows) => {
+  const unique = /* @__PURE__ */ new Map();
+  if (rows.length > 2e4)
+    throw new Error(
+      "Jev training is bounded to 20000 rows; select a frozen sample first"
+    );
+  for (const row of rows) {
+    const record = row?.record;
+    if (row?.schema !== "tradejs-jev-study/v4" || !row.signalId || record?.schema !== "tradejs-jev-record/v4" || record.input?.schema !== "tradejs-jev-input/v4" || !Number.isFinite(record.input.timestamp) || record.inputHash !== jevHash(record.input) || record.questionsHash !== jevHash(questionsForJevInput(record.input)) || record.id !== jevHash({
+      inputHash: record.inputHash,
+      questionsHash: record.questionsHash,
+      provider: record.provider
+    }))
+      throw new Error("Invalid Jev study provenance");
+    validateJevResponse(record.response, record.input.questions);
+    for (const dimension of JEV_DIMENSIONS2) {
+      const expected = record.input.questions.includes(dimension) ? record.response.answers[dimension].score / 4 : null;
+      if (record.scores[dimension] !== expected)
+        throw new Error("Jev study scores do not match the teacher response");
+    }
+    if (row.profit != null && !Number.isFinite(row.profit))
+      throw new Error("Invalid study outcome");
+    const prior = unique.get(record.inputHash);
+    if (prior && (prior.record.id !== record.id || prior.profit !== row.profit || jevHash(prior.record.response) !== jevHash(record.response)))
+      throw new Error("Conflicting duplicated Jev sample");
+    unique.set(record.inputHash, row);
+  }
+  const ordered = [...unique.values()].sort(
+    (a, b) => a.record.input.timestamp - b.record.input.timestamp || a.record.id.localeCompare(b.record.id)
+  );
+  if (!ordered.length) throw new Error("Empty Jev study");
+  const first = ordered[0].record;
+  if (ordered.some(
+    (row) => row.record.input.strategy !== first.input.strategy || row.record.response.model !== first.response.model || jevHash(row.record.provider) !== jevHash(first.provider)
+  ))
+    throw new Error(
+      "Train one strategy and one frozen teacher/provider lineage at a time"
+    );
+  return ordered;
+};
+var trainTree = (rows, dimension, depth, minLeaf) => {
+  const values = rows.map((row) => row.record.scores[dimension]);
+  const leaf = { value: mean(values), samples: rows.length };
+  if (depth === 0 || rows.length < minLeaf * 2 || variance(values) < 1e-8)
+    return leaf;
+  const keys = [
+    ...new Set(rows.flatMap((row) => Object.keys(row.record.input.features)))
+  ].sort().filter(
+    (key) => new Set(rows.map((row) => row.record.input.features[key])).size > 1
+  );
+  if (keys.length > 2e3) throw new Error("Too many Jev student features");
+  let best;
+  let bestLoss = variance(values);
+  for (const feature of keys) {
+    const observed = [
+      ...new Set(
+        rows.map((row) => row.record.input.features[feature]).filter((value) => value != null)
+      )
+    ];
+    const numeric = observed.every((value) => typeof value === "number");
+    const sorted = numeric ? observed.sort((a, b) => a - b) : observed.sort((a, b) => String(a).localeCompare(String(b)));
+    const candidates = sorted.filter(
+      (_, index) => index % Math.max(1, Math.ceil(sorted.length / 12)) === 0
+    ).slice(0, 12);
+    for (const value of candidates)
+      for (const missingLeft of [true, false]) {
+        const left = [], right = [];
+        for (const row of rows) {
+          const input = row.record.input.features[feature];
+          const goesLeft = input == null ? missingLeft : numeric ? typeof input === "number" && input <= value : input === value;
+          (goesLeft ? left : right).push(row);
+        }
+        if (left.length < minLeaf || right.length < minLeaf) continue;
+        const loss = variance(left.map((row) => row.record.scores[dimension])) + variance(right.map((row) => row.record.scores[dimension]));
+        if (loss < bestLoss - 1e-8) {
+          bestLoss = loss;
+          best = {
+            feature,
+            operator: numeric ? "lte" : "eq",
+            value,
+            missingLeft,
+            left,
+            right
+          };
+        }
+      }
+  }
+  if (!best) return leaf;
+  return {
+    feature: best.feature,
+    operator: best.operator,
+    value: best.value,
+    missingLeft: best.missingLeft,
+    left: trainTree(best.left, dimension, depth - 1, minLeaf),
+    right: trainTree(best.right, dimension, depth - 1, minLeaf)
+  };
+};
+var validateJevGateModel = (value) => {
+  const model = value;
+  if (model?.schema !== "tradejs-jev-gate/v2" || model.inputSchema !== "tradejs-jev-input/v4" || typeof model.strategy !== "string" || !model.strategy || !model.teacherModel || !model.trees || model.questionsHash !== jevHash(JEV_QUESTIONS) || !model.training || !/^[a-f0-9]{64}$/.test(model.training.datasetHash))
+    throw new Error("Invalid local Jev gate");
+  const { trainEnd, validationEnd, testEnd } = model.training;
+  if (![trainEnd, validationEnd, testEnd].every(Number.isFinite) || !(trainEnd < validationEnd && validationEnd < testEnd))
+    throw new Error("Invalid local Jev gate partitions");
+  const check = (tree, depth) => {
+    if (!tree || depth > 8) throw new Error("Invalid local Jev tree");
+    if ("samples" in tree) {
+      if (!Number.isFinite(tree.value) || tree.value < 0 || tree.value > 1 || !Number.isInteger(tree.samples) || tree.samples < 1)
+        throw new Error("Invalid local Jev leaf");
+      return;
+    }
+    if (typeof tree.feature !== "string" || !["lte", "eq"].includes(tree.operator) || typeof tree.missingLeft !== "boolean" || tree.operator === "lte" && !Number.isFinite(tree.value) || !["number", "boolean", "string"].includes(typeof tree.value))
+      throw new Error("Invalid local Jev split");
+    check(tree.left, depth + 1);
+    check(tree.right, depth + 1);
+  };
+  for (const dimension of JEV_DIMENSIONS2) {
+    if (model.trees[dimension] != null) check(model.trees[dimension], 0);
+  }
+  return model;
+};
+var predict = (model, row) => Object.fromEntries(
+  JEV_DIMENSIONS2.map((key) => [
+    key,
+    model.trees[key] && row.record.input.questions.includes(key) ? predictJevTree(model.trees[key], row.record.input.features) : null
+  ])
+);
+var economics = (rows) => {
+  const known = rows.filter((row) => row.profit != null);
+  const profits = known.map((row) => row.profit);
+  const wins = profits.filter((value) => value > 0).reduce((sum, value) => sum + value, 0);
+  const losses = -profits.filter((value) => value < 0).reduce((sum, value) => sum + value, 0);
+  return {
+    rows: rows.length,
+    knownOutcomes: known.length,
+    pnl: profits.reduce((a, b) => a + b, 0),
+    pnlPerTrade: profits.length ? mean(profits) : null,
+    profitFactor: losses ? wins / losses : null,
+    winRate: profits.length ? profits.filter((value) => value > 0).length / profits.length : null
+  };
+};
+var compareJevGate = (model, input, minScores = {}) => {
+  validateJevGateModel(model);
+  const rows = validateJevStudy(input);
+  if (rows.some(
+    (row) => row.record.input.strategy !== model.strategy || row.record.response.model !== model.teacherModel
+  ))
+    throw new Error("Model and study lineage do not match");
+  const decisions = rows.map((row) => {
+    const policy = {
+      source: "local",
+      mode: "gate",
+      minScores
+    };
+    const scores = predict(model, row);
+    const student = decideJev(
+      scores,
+      policy,
+      row.record.input.geometryStatus,
+      row.record.input.features,
+      row.record.input.questions
+    ).allowed;
+    const teacher = decideJev(
+      row.record.scores,
+      policy,
+      row.record.input.geometryStatus,
+      row.record.input.features,
+      row.record.input.questions
+    ).allowed;
+    return { row, scores, student, teacher };
+  });
+  const dimensionErrors = Object.fromEntries(
+    JEV_DIMENSIONS2.map((key) => {
+      const pairs = decisions.filter(
+        (item) => item.row.record.scores[key] != null && item.scores[key] != null
+      );
+      return [
+        key,
+        {
+          n: pairs.length,
+          mae: pairs.length ? mean(
+            pairs.map(
+              (item) => Math.abs(item.scores[key] - item.row.record.scores[key])
+            )
+          ) : null
+        }
+      ];
+    })
+  );
+  const selected = (predicate) => decisions.filter(predicate).map((value) => value.row);
+  return {
+    rows: rows.length,
+    start: rows[0].record.input.timestamp,
+    end: rows[rows.length - 1].record.input.timestamp,
+    agreement: decisions.filter((item) => item.student === item.teacher).length / rows.length,
+    teacherOnly: decisions.filter((item) => item.teacher && !item.student).length,
+    studentOnly: decisions.filter((item) => item.student && !item.teacher).length,
+    dimensionErrors,
+    outcomeScope: "Matched completed outcomes only; this is not a sequential portfolio backtest. Unexecuted candidates have no observed outcome.",
+    cohorts: Object.fromEntries(
+      ["ALL", "LONG", "SHORT"].map((side) => [
+        side,
+        {
+          core: economics(
+            selected(
+              (item) => side === "ALL" || item.row.record.input.direction === side
+            )
+          ),
+          baseline: economics(
+            selected(
+              (item) => item.row.baselineAllowed === true && (side === "ALL" || item.row.record.input.direction === side)
+            )
+          ),
+          jev: economics(
+            selected(
+              (item) => item.teacher && (side === "ALL" || item.row.record.input.direction === side)
+            )
+          ),
+          local: economics(
+            selected(
+              (item) => item.student && (side === "ALL" || item.row.record.input.direction === side)
+            )
+          )
+        }
+      ])
+    )
+  };
+};
+var trainJevGate = (input, options = {}) => {
+  const rows = validateJevStudy(input);
+  const maxDepth = options.maxDepth ?? 3, minLeaf = options.minLeaf ?? 10;
+  if (!Number.isInteger(maxDepth) || maxDepth < 1 || maxDepth > 6 || !Number.isInteger(minLeaf) || minLeaf < 2)
+    throw new Error("Invalid Jev training limits");
+  const timestamps = [
+    ...new Set(rows.map((row) => row.record.input.timestamp))
+  ];
+  if (rows.length < 30 || timestamps.length < 10)
+    throw new Error("Need at least 30 distinct samples across 10 signal times");
+  const trainEnd = timestamps[Math.floor(timestamps.length * 0.6) - 1];
+  const validationEnd = timestamps[Math.floor(timestamps.length * 0.8) - 1];
+  const train = rows.filter((row) => row.record.input.timestamp <= trainEnd);
+  const validation = rows.filter(
+    (row) => row.record.input.timestamp > trainEnd && row.record.input.timestamp <= validationEnd
+  );
+  const test = rows.filter((row) => row.record.input.timestamp > validationEnd);
+  const fit = (samples) => Object.fromEntries(
+    JEV_DIMENSIONS2.map((key) => {
+      const eligible = samples.filter(
+        (row) => row.record.scores[key] != null
+      );
+      return [
+        key,
+        eligible.length ? trainTree(eligible, key, maxDepth, minLeaf) : null
+      ];
+    })
+  );
+  const first = rows[0].record;
+  const model = {
+    schema: "tradejs-jev-gate/v2",
+    inputSchema: "tradejs-jev-input/v4",
+    strategy: first.input.strategy,
+    questionsHash: jevHash(JEV_QUESTIONS),
+    teacherModel: first.response.model,
+    trees: fit(train),
+    training: {
+      datasetHash: jevHash(
+        rows.map((row) => ({
+          id: row.record.id,
+          response: row.record.response
+        }))
+      ),
+      trainEnd,
+      validationEnd,
+      testEnd: timestamps[timestamps.length - 1],
+      maxDepth,
+      minLeaf
+    }
+  };
+  validateJevGateModel(model);
+  const walkForward = [0.4, 0.6, 0.8].map((fraction) => {
+    const trainThrough = timestamps[Math.max(0, Math.floor(timestamps.length * (fraction - 0.1)) - 1)];
+    const validationThrough = timestamps[Math.floor(timestamps.length * fraction) - 1];
+    const testThrough = timestamps[Math.min(
+      timestamps.length - 1,
+      Math.round(timestamps.length * (fraction + 0.2)) - 1
+    )];
+    const fitting = rows.filter(
+      (row) => row.record.input.timestamp <= trainThrough
+    );
+    const evaluation = rows.filter(
+      (row) => row.record.input.timestamp > validationThrough && row.record.input.timestamp <= testThrough
+    );
+    const fold = {
+      ...model,
+      trees: fit(fitting),
+      training: {
+        ...model.training,
+        trainEnd: trainThrough,
+        validationEnd: validationThrough,
+        testEnd: testThrough
+      }
+    };
+    return {
+      trainThrough,
+      validationThrough,
+      testThrough,
+      trainRows: fitting.length,
+      test: compareJevGate(fold, evaluation)
+    };
+  });
+  return {
+    model,
+    report: {
+      train: compareJevGate(model, train),
+      validation: compareJevGate(model, validation),
+      test: compareJevGate(model, test),
+      walkForward,
+      promotion: "research-only; validate a sequential backtest and prospective signals before runtime admission"
+    }
+  };
+};
+
+export {
+  buildJevInput,
+  JEV_QUESTIONS,
+  questionsForJevInput,
+  stateForJevInput,
+  validateJevStudy,
+  validateJevGateModel,
+  compareJevGate,
+  trainJevGate
+};

package/dist/cli.js

@@ -1184,8 +1184,11 @@ var toRecord2 = (value) => {
   return value;
 };
 var buildBaseAiPayload = (signal) => {
+  const { jevEvidence: _jevEvidence, ...signalAdditionalIndicators } = toRecord2(
+    signal.additionalIndicators
+  );
   const additionalIndicators = {
-    ...toRecord2(signal.additionalIndicators),
+    ...signalAdditionalIndicators,
     marketContext: buildAiMarketContext(signal)
   };
   return {
@@ -2328,6 +2331,7 @@ var formatMessage = (signal, analysis, _options = {}) => {
     symbol,
     direction,
     strategy,
+    deploymentId,
     orderStatus,
     orderSkipReason,
     orderFailureReason,
@@ -2360,6 +2364,9 @@ var formatMessage = (signal, analysis, _options = {}) => {
       const emojiDir = direction === "LONG" ? "\u{1F7E9} LONG" : direction === "SHORT" ? "\u{1F7E5} SHORT" : "\u2B1C\uFE0F NO TRADE";
       lines.push(`<b>${emojiDir} ${symbol}</b>`);
       lines.push(`Strategy: ${strategy}`);
+      if (deploymentId) {
+        lines.push(`Deployment: ${escapeHtml(deploymentId)}`);
+      }
       lines.push("");
       if (orderStatus) {
         let orderStatusText = "\u26AA\uFE0F Order skipped";
@@ -2870,6 +2877,7 @@ var formatRuntimeCloseNotification = (event, _userName = event.userName ?? "root
     "<b>Strategy self-close</b>",
     `Symbol: <b>${escapeHtml2(event.symbol)}</b>`,
     `Strategy: <b>${escapeHtml2(event.strategy)}</b>`,
+    ...event.deploymentId ? [`Deployment: <b>${escapeHtml2(event.deploymentId)}</b>`] : [],
     `Direction: <b>${escapeHtml2(event.direction)}</b>`,
     `Reason: <code>${escapeHtml2(event.code)}</code>`,
     "",

package/dist/cli.mjs

@@ -6,7 +6,7 @@ import {
 import {
   askAI,
   ensureStrategyPluginsLoaded
-} from "./chunk-UITD6LG6.mjs";
+} from "./chunk-UL5Z46JL.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
@@ -741,6 +741,7 @@ var formatMessage = (signal, analysis, _options = {}) => {
     symbol,
     direction,
     strategy,
+    deploymentId,
     orderStatus,
     orderSkipReason,
     orderFailureReason,
@@ -773,6 +774,9 @@ var formatMessage = (signal, analysis, _options = {}) => {
       const emojiDir = direction === "LONG" ? "\u{1F7E9} LONG" : direction === "SHORT" ? "\u{1F7E5} SHORT" : "\u2B1C\uFE0F NO TRADE";
       lines.push(`<b>${emojiDir} ${symbol}</b>`);
       lines.push(`Strategy: ${strategy}`);
+      if (deploymentId) {
+        lines.push(`Deployment: ${escapeHtml(deploymentId)}`);
+      }
       lines.push("");
       if (orderStatus) {
         let orderStatusText = "\u26AA\uFE0F Order skipped";
@@ -1283,6 +1287,7 @@ var formatRuntimeCloseNotification = (event, _userName = event.userName ?? "root
     "<b>Strategy self-close</b>",
     `Symbol: <b>${escapeHtml2(event.symbol)}</b>`,
     `Strategy: <b>${escapeHtml2(event.strategy)}</b>`,
+    ...event.deploymentId ? [`Deployment: <b>${escapeHtml2(event.deploymentId)}</b>`] : [],
     `Direction: <b>${escapeHtml2(event.direction)}</b>`,
     `Reason: <code>${escapeHtml2(event.code)}</code>`,
     "",