@tradejs/node 3.1.28 → 3.1.29-beta.259

package/dist/jev.js

@@ -0,0 +1,931 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/jevInput.ts
+var import_data, import_jev, object, at, finite, fact, buildJevInput, criteria, JEV_QUESTIONS, questionsForJevInput, stateForJevInput;
+var init_jevInput = __esm({
+  "src/jevInput.ts"() {
+    "use strict";
+    import_data = require("@tradejs/core/data");
+    import_jev = require("@tradejs/core/jev");
+    object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    at = (value, ...path2) => path2.reduce((current, key) => object(current)[key], value);
+    finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+    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");
+    };
+    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 > (0, import_data.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 = import_jev.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
+      };
+    };
+    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.`
+    ];
+    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")
+      }
+    };
+    questionsForJevInput = (input) => Object.fromEntries(input.questions.map((key) => [key, JEV_QUESTIONS[key]]));
+    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 jevTraining_exports = {};
+__export(jevTraining_exports, {
+  compareJevGate: () => compareJevGate,
+  trainJevGate: () => trainJevGate,
+  validateJevGateModel: () => validateJevGateModel,
+  validateJevStudy: () => validateJevStudy
+});
+var import_jev2, import_jev3, mean, variance, validateJevStudy, trainTree, validateJevGateModel, predict, economics, compareJevGate, trainJevGate;
+var init_jevTraining = __esm({
+  "src/jevTraining.ts"() {
+    "use strict";
+    import_jev2 = require("@tradejs/core/jev");
+    import_jev3 = require("@tradejs/infra/jev");
+    init_jevInput();
+    mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
+    variance = (values) => {
+      const average = mean(values);
+      return values.reduce((sum, value) => sum + (value - average) ** 2, 0);
+    };
+    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 !== (0, import_jev3.jevHash)(record.input) || record.questionsHash !== (0, import_jev3.jevHash)(questionsForJevInput(record.input)) || record.id !== (0, import_jev3.jevHash)({
+          inputHash: record.inputHash,
+          questionsHash: record.questionsHash,
+          provider: record.provider
+        }))
+          throw new Error("Invalid Jev study provenance");
+        (0, import_jev3.validateJevResponse)(record.response, record.input.questions);
+        for (const dimension of import_jev2.JEV_DIMENSIONS) {
+          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 || (0, import_jev3.jevHash)(prior.record.response) !== (0, import_jev3.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 || (0, import_jev3.jevHash)(row.record.provider) !== (0, import_jev3.jevHash)(first.provider)
+      ))
+        throw new Error(
+          "Train one strategy and one frozen teacher/provider lineage at a time"
+        );
+      return ordered;
+    };
+    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)
+      };
+    };
+    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 !== (0, import_jev3.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 import_jev2.JEV_DIMENSIONS) {
+        if (model.trees[dimension] != null) check(model.trees[dimension], 0);
+      }
+      return model;
+    };
+    predict = (model, row) => Object.fromEntries(
+      import_jev2.JEV_DIMENSIONS.map((key) => [
+        key,
+        model.trees[key] && row.record.input.questions.includes(key) ? (0, import_jev2.predictJevTree)(model.trees[key], row.record.input.features) : null
+      ])
+    );
+    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
+      };
+    };
+    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 = (0, import_jev2.decideJev)(
+          scores,
+          policy,
+          row.record.input.geometryStatus,
+          row.record.input.features,
+          row.record.input.questions
+        ).allowed;
+        const teacher = (0, import_jev2.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(
+        import_jev2.JEV_DIMENSIONS.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)
+                )
+              )
+            }
+          ])
+        )
+      };
+    };
+    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(
+        import_jev2.JEV_DIMENSIONS.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: (0, import_jev3.jevHash)(JEV_QUESTIONS),
+        teacherModel: first.response.model,
+        trees: fit(train),
+        training: {
+          datasetHash: (0, import_jev3.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"
+        }
+      };
+    };
+  }
+});
+
+// src/jev.ts
+var jev_exports = {};
+__export(jev_exports, {
+  JEV_QUESTIONS: () => JEV_QUESTIONS,
+  assessSignalWithJev: () => assessSignalWithJev,
+  buildJevInput: () => buildJevInput,
+  compareJevGate: () => compareJevGate,
+  evaluateJevInput: () => evaluateJevInput,
+  resolveJevProvider: () => resolveJevProvider,
+  trainJevGate: () => trainJevGate,
+  validateJevGateModel: () => validateJevGateModel
+});
+module.exports = __toCommonJS(jev_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_jev4 = require("@tradejs/core/jev");
+var import_jev5 = require("@tradejs/infra/jev");
+var import_userSettings = require("@tradejs/infra/userSettings");
+init_jevInput();
+init_jevInput();
+init_jevTraining();
+var resolveJevProvider = async (userName) => {
+  const settings = await (0, import_userSettings.getUserSettings)(userName);
+  const provider = {
+    endpoint: settings.JEV_API_ENDPOINT || import_jev4.JEV_PROVIDERS[0].endpoint,
+    model: settings.JEV_MODEL || import_jev4.JEV_PROVIDERS[0].model
+  };
+  (0, import_jev4.parseJevConfig)({ source: "provider", mode: "observe", provider });
+  if (!settings.JEV_API_KEY)
+    throw new Error("Configure the Jev API key in Account settings");
+  return provider;
+};
+var emptyScores = () => Object.fromEntries(import_jev4.JEV_DIMENSIONS.map((key) => [key, null]));
+var pending = /* @__PURE__ */ new Map();
+var pendingResponses = /* @__PURE__ */ new Map();
+var evaluateJevInput = async ({
+  input,
+  config,
+  userName,
+  projectRoot
+}) => {
+  config = (0, import_jev4.parseJevConfig)(config);
+  const inputHash = (0, import_jev5.jevHash)(input);
+  const questions = questionsForJevInput(input);
+  const questionsHash = (0, import_jev5.jevHash)(questions);
+  const base = {
+    schema: "tradejs-signal-assessment/v5",
+    source: config.source,
+    mode: config.mode,
+    inputHash,
+    questionsHash,
+    geometryStatus: input.geometryStatus,
+    levelsValid: typeof input.features["signal.validLevels"] === "boolean" ? input.features["signal.validLevels"] : null
+  };
+  if (!input.questions.length)
+    return {
+      assessment: {
+        ...base,
+        status: "unavailable",
+        model: "",
+        scores: emptyScores(),
+        confidence: emptyScores()
+      }
+    };
+  if (config.source === "local") {
+    const contents = await import_promises.default.readFile(
+      import_node_path.default.resolve(projectRoot, config.modelFile),
+      "utf8"
+    );
+    if ((0, import_jev5.jevFileHash)(contents) !== config.modelSha256)
+      throw new Error("Local Jev gate checksum mismatch");
+    const { validateJevGateModel: validateJevGateModel2 } = await Promise.resolve().then(() => (init_jevTraining(), jevTraining_exports));
+    const model = validateJevGateModel2(JSON.parse(contents));
+    if (model.strategy !== input.strategy || model.questionsHash !== (0, import_jev5.jevHash)(JEV_QUESTIONS))
+      throw new Error("Local Jev gate strategy or question version mismatch");
+    const scores = Object.fromEntries(
+      import_jev4.JEV_DIMENSIONS.map((key) => [
+        key,
+        input.questions.includes(key) && model.trees[key] ? (0, import_jev4.predictJevTree)(model.trees[key], input.features) : null
+      ])
+    );
+    return {
+      assessment: {
+        ...base,
+        status: "available",
+        model: config.modelSha256,
+        scores,
+        confidence: emptyScores()
+      }
+    };
+  }
+  const provider = config.provider ?? await resolveJevProvider(userName);
+  const id = (0, import_jev5.jevHash)({ inputHash, questionsHash, provider });
+  const dir = import_node_path.default.resolve(projectRoot, config.recordsDir ?? "data/ai/jev");
+  const file = import_node_path.default.join(dir, "records", `${id}.json`);
+  const getRecord = async () => {
+    const existing = await (0, import_jev5.readJevArtifact)(file);
+    if (existing) {
+      if (existing.schema !== "tradejs-jev-record/v4" || existing.id !== id || existing.inputHash !== inputHash || existing.questionsHash !== questionsHash || (0, import_jev5.jevHash)(existing.input) !== inputHash || (0, import_jev5.jevHash)(existing.provider) !== (0, import_jev5.jevHash)(provider))
+        throw new Error("Jev recording identity mismatch");
+      (0, import_jev5.validateJevResponse)(existing.response, input.questions);
+      for (const key of import_jev4.JEV_DIMENSIONS) {
+        const expected = input.questions.includes(key) ? existing.response.answers[key].score / 4 : null;
+        if (existing.scores[key] !== expected)
+          throw new Error("Jev recording scores do not match the response");
+      }
+      return existing;
+    }
+    if (config.source === "recorded")
+      throw new Error(
+        `Missing Jev recording ${id} for ${input.strategy} ${input.symbol} at ${new Date(input.timestamp).toISOString()}. Recorded mode requires the same signal-time facts and provider; a shorter backtest can change warm-up indicators or prior trade state.`
+      );
+    const settings = await (0, import_userSettings.getUserSettings)(userName);
+    if (!settings.JEV_API_KEY)
+      throw new Error("Configure the Jev API key in Account settings");
+    const apiKey = settings.JEV_API_KEY;
+    const configuredProvider = await resolveJevProvider(userName);
+    if (configuredProvider.endpoint !== provider.endpoint)
+      throw new Error(
+        "Jev account endpoint changed; update the frozen provider configuration"
+      );
+    const started = Date.now();
+    const state = stateForJevInput(input);
+    const responseId = (0, import_jev5.jevHash)({
+      state,
+      questionsHash,
+      provider,
+      user: (0, import_jev5.jevHash)(userName)
+    });
+    const responseFile = import_node_path.default.join(dir, "responses", `${responseId}.json`);
+    let responsePromise = pendingResponses.get(responseFile);
+    if (!responsePromise) {
+      responsePromise = (async () => {
+        const saved = await (0, import_jev5.readJevArtifact)(responseFile);
+        if (saved) return (0, import_jev5.validateJevResponse)(saved, input.questions);
+        const fresh = await (0, import_jev5.requestJev)(provider, apiKey, state, questions);
+        await (0, import_jev5.writeJevArtifact)(responseFile, fresh);
+        return fresh;
+      })();
+      pendingResponses.set(responseFile, responsePromise);
+    }
+    let response;
+    try {
+      response = await responsePromise;
+    } finally {
+      pendingResponses.delete(responseFile);
+    }
+    const scores = Object.fromEntries(
+      import_jev4.JEV_DIMENSIONS.map((key) => [
+        key,
+        input.questions.includes(key) ? response.answers[key].score / 4 : null
+      ])
+    );
+    const value = {
+      schema: "tradejs-jev-record/v4",
+      id,
+      inputHash,
+      questionsHash,
+      provider,
+      input,
+      response,
+      scores,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      elapsedMs: Date.now() - started
+    };
+    await (0, import_jev5.writeJevArtifact)(file, value);
+    return await (0, import_jev5.readJevArtifact)(file);
+  };
+  const pendingKey = `${file}:${(0, import_jev5.jevHash)(userName)}`;
+  let promise = pending.get(pendingKey);
+  if (!promise) {
+    promise = getRecord();
+    pending.set(pendingKey, promise);
+  }
+  let record;
+  try {
+    record = await promise;
+  } finally {
+    pending.delete(pendingKey);
+  }
+  return {
+    record,
+    assessment: {
+      ...base,
+      status: "available",
+      recordId: id,
+      model: record.response.model,
+      scores: record.scores,
+      confidence: Object.fromEntries(
+        import_jev4.JEV_DIMENSIONS.map((key) => [
+          key,
+          record.response.answers[key]?.confidence ?? null
+        ])
+      )
+    }
+  };
+};
+var assessSignalWithJev = async ({
+  signal,
+  config,
+  userName,
+  projectRoot,
+  strict,
+  scope = "runtime"
+}) => {
+  let assessment;
+  try {
+    const input = buildJevInput(signal);
+    ({ assessment } = await evaluateJevInput({
+      input,
+      config,
+      userName,
+      projectRoot
+    }));
+  } catch (error) {
+    if (strict) throw error;
+    assessment = {
+      schema: "tradejs-signal-assessment/v5",
+      source: config.source,
+      mode: config.mode,
+      status: "unavailable",
+      inputHash: "",
+      questionsHash: "",
+      geometryStatus: "absent",
+      levelsValid: null,
+      model: config.provider?.model ?? config.modelSha256 ?? "",
+      scores: emptyScores(),
+      confidence: emptyScores()
+    };
+  }
+  signal.assessment = assessment;
+  signal.additionalIndicators = {
+    ...signal.additionalIndicators,
+    jev: {
+      schema: "tradejs-jev-features/v2",
+      status: assessment.status,
+      scores: assessment.scores,
+      confidence: assessment.confidence
+    }
+  };
+  const identity = {
+    signalId: signal.signalId,
+    strategy: signal.strategy,
+    symbol: signal.symbol,
+    timestamp: signal.timestamp,
+    scope,
+    user: (0, import_jev5.jevHash)(userName),
+    config,
+    assessment
+  };
+  await (0, import_jev5.writeJevArtifact)(
+    import_node_path.default.resolve(
+      projectRoot,
+      config.recordsDir ?? "data/ai/jev",
+      "decisions",
+      `${(0, import_jev5.jevHash)(identity)}.json`
+    ),
+    identity
+  );
+  return assessment;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JEV_QUESTIONS,
+  assessSignalWithJev,
+  buildJevInput,
+  compareJevGate,
+  evaluateJevInput,
+  resolveJevProvider,
+  trainJevGate,
+  validateJevGateModel
+});