@tradejs/node 3.1.28 → 3.1.29-beta.259

package/dist/backtest.mjs

@@ -5,14 +5,16 @@ import {
 import {
   buildMlPayload,
   enrichSignalWithMarketContextStages
-} from "./chunk-JDFPF2RG.mjs";
+} from "./chunk-WGL7XJ3W.mjs";
 import {
   buildAiPayload,
   getStrategyCreator
-} from "./chunk-UITD6LG6.mjs";
+} from "./chunk-UL5Z46JL.mjs";
 import {
   getTradejsProjectCwd
 } from "./chunk-LZDXRXIU.mjs";
+import "./chunk-3BBXGZ7M.mjs";
+import "./chunk-ZZQLTUTP.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 
 // src/backtest.ts
@@ -1364,6 +1366,7 @@ var buildReplayEvaluation = ({
     orderStatus: signal.orderStatus,
     orderSkipReason: signal.orderSkipReason,
     aiAnalysis: signal.aiAnalysis ?? null,
+    assessment: signal.assessment,
     ml: signal.ml
   };
 };
@@ -1502,7 +1505,7 @@ var createBacktestSession = async ({
         })
       );
     }
-    if (test.ai && signal && typeof signal !== "string" && signal.signalId) {
+    if (test.ai && signal && typeof signal !== "string" && signal.signalId && !(signal.assessment && signal.orderStatus === "skipped")) {
       pendingAiRowBySignalId.set(signal.signalId, {
         signalId: signal.signalId,
         strategyName: signal.strategy || test.strategyName,
@@ -1510,6 +1513,7 @@ var createBacktestSession = async ({
         direction: signal.direction,
         timestamp: signal.timestamp,
         signal: cloneSignal(signal),
+        assessment: signal.assessment,
         testId: test.testId,
         testSuiteId: test.testSuiteId,
         testName: test.name,

package/dist/chunk-3BBXGZ7M.mjs

@@ -0,0 +1,271 @@
+import {
+  JEV_QUESTIONS,
+  buildJevInput,
+  questionsForJevInput,
+  stateForJevInput
+} from "./chunk-ZZQLTUTP.mjs";
+
+// src/jev.ts
+import fs from "fs/promises";
+import path from "path";
+import {
+  JEV_DIMENSIONS,
+  JEV_PROVIDERS,
+  parseJevConfig,
+  predictJevTree
+} from "@tradejs/core/jev";
+import {
+  jevHash,
+  jevFileHash,
+  readJevArtifact,
+  writeJevArtifact,
+  requestJev,
+  validateJevResponse
+} from "@tradejs/infra/jev";
+import { getUserSettings } from "@tradejs/infra/userSettings";
+var resolveJevProvider = async (userName) => {
+  const settings = await getUserSettings(userName);
+  const provider = {
+    endpoint: settings.JEV_API_ENDPOINT || JEV_PROVIDERS[0].endpoint,
+    model: settings.JEV_MODEL || JEV_PROVIDERS[0].model
+  };
+  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(JEV_DIMENSIONS.map((key) => [key, null]));
+var pending = /* @__PURE__ */ new Map();
+var pendingResponses = /* @__PURE__ */ new Map();
+var evaluateJevInput = async ({
+  input,
+  config,
+  userName,
+  projectRoot
+}) => {
+  config = parseJevConfig(config);
+  const inputHash = jevHash(input);
+  const questions = questionsForJevInput(input);
+  const questionsHash = 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 fs.readFile(
+      path.resolve(projectRoot, config.modelFile),
+      "utf8"
+    );
+    if (jevFileHash(contents) !== config.modelSha256)
+      throw new Error("Local Jev gate checksum mismatch");
+    const { validateJevGateModel: validateJevGateModel2 } = await import("./jevTraining-JYXUVAZG.mjs");
+    const model = validateJevGateModel2(JSON.parse(contents));
+    if (model.strategy !== input.strategy || model.questionsHash !== jevHash(JEV_QUESTIONS))
+      throw new Error("Local Jev gate strategy or question version mismatch");
+    const scores = Object.fromEntries(
+      JEV_DIMENSIONS.map((key) => [
+        key,
+        input.questions.includes(key) && model.trees[key] ? 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 = jevHash({ inputHash, questionsHash, provider });
+  const dir = path.resolve(projectRoot, config.recordsDir ?? "data/ai/jev");
+  const file = path.join(dir, "records", `${id}.json`);
+  const getRecord = async () => {
+    const existing = await readJevArtifact(file);
+    if (existing) {
+      if (existing.schema !== "tradejs-jev-record/v4" || existing.id !== id || existing.inputHash !== inputHash || existing.questionsHash !== questionsHash || jevHash(existing.input) !== inputHash || jevHash(existing.provider) !== jevHash(provider))
+        throw new Error("Jev recording identity mismatch");
+      validateJevResponse(existing.response, input.questions);
+      for (const key of 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 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 = jevHash({
+      state,
+      questionsHash,
+      provider,
+      user: jevHash(userName)
+    });
+    const responseFile = path.join(dir, "responses", `${responseId}.json`);
+    let responsePromise = pendingResponses.get(responseFile);
+    if (!responsePromise) {
+      responsePromise = (async () => {
+        const saved = await readJevArtifact(responseFile);
+        if (saved) return validateJevResponse(saved, input.questions);
+        const fresh = await requestJev(provider, apiKey, state, questions);
+        await writeJevArtifact(responseFile, fresh);
+        return fresh;
+      })();
+      pendingResponses.set(responseFile, responsePromise);
+    }
+    let response;
+    try {
+      response = await responsePromise;
+    } finally {
+      pendingResponses.delete(responseFile);
+    }
+    const scores = Object.fromEntries(
+      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 writeJevArtifact(file, value);
+    return await readJevArtifact(file);
+  };
+  const pendingKey = `${file}:${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(
+        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: jevHash(userName),
+    config,
+    assessment
+  };
+  await writeJevArtifact(
+    path.resolve(
+      projectRoot,
+      config.recordsDir ?? "data/ai/jev",
+      "decisions",
+      `${jevHash(identity)}.json`
+    ),
+    identity
+  );
+  return assessment;
+};
+
+export {
+  resolveJevProvider,
+  evaluateJevInput,
+  assessSignalWithJev
+};

package/dist/{chunk-K2YQ3MQC.mjs → chunk-BO42QWAB.mjs}

@@ -2,12 +2,13 @@ import {
   getStrategyCreator,
   getStrategyEntry,
   getStrategyPluginSource
-} from "./chunk-UITD6LG6.mjs";
+} from "./chunk-UL5Z46JL.mjs";
 import {
   loadTradejsConfig
 } from "./chunk-LZDXRXIU.mjs";
 
 // src/runtimeStrategies.ts
+import { parseJevConfig } from "@tradejs/core/jev";
 import { createHash } from "crypto";
 import { readFile } from "fs/promises";
 import path from "path";
@@ -347,7 +348,15 @@ var resolveStrategyComposition = async ({
       `Strategy config parser returned a non-object: ${strategyName}`
     );
   }
-  const strategyConfig = parsedConfig;
+  const jev = parseJevConfig(declaration.config.JEV);
+  if (jev && jev.source === "provider" && !jev.provider)
+    throw new Error(
+      "Runtime JEV requires a frozen provider endpoint and model"
+    );
+  const strategyConfig = {
+    ...parsedConfig,
+    ...jev ? { JEV: jev } : {}
+  };
   const selection = resolveStrategySelection({
     deployment,
     strategy: declaration

package/dist/{chunk-UITD6LG6.mjs → chunk-UL5Z46JL.mjs}

@@ -1034,8 +1034,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 {

package/dist/{chunk-JDFPF2RG.mjs → chunk-WGL7XJ3W.mjs}

@@ -5,11 +5,14 @@ import {
   resolveStrategyPolicyProfile,
   runAiPromptLocal,
   setStrategyRuntimeFactory
-} from "./chunk-UITD6LG6.mjs";
+} from "./chunk-UL5Z46JL.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
 } from "./chunk-LZDXRXIU.mjs";
+import {
+  assessSignalWithJev
+} from "./chunk-3BBXGZ7M.mjs";
 
 // src/binanceBreadthUniverses.ts
 import { createHash } from "crypto";
@@ -3104,7 +3107,8 @@ var executeEntryOrder = async ({
       runtimeConfigId: signal.runtimeConfigId,
       strategyRevision: signal.strategyRevision,
       runtimeLineage: signal.runtimeLineage,
-      ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
+      ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
+      ...signal.assessment ? { assessment: signal.assessment } : {}
     });
   }
   if (orderPlaced && recordRuntimeTrade && isPositionIncrease) {
@@ -3176,6 +3180,7 @@ var resolveStrategyConfig = async ({
 };
 
 // src/strategyRuntime.ts
+import { parseJevConfig } from "@tradejs/core/jev";
 import {
   BACKTEST_EXECUTION_DELAY_MS,
   BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED
@@ -3847,6 +3852,7 @@ var handleExitDecision = async ({
         onRuntimeClose?.({
           userName,
           strategy: strategyName,
+          deploymentId: connector.deploymentId,
           openedByStrategy: trade.strategy,
           symbol,
           direction: trade.direction,
@@ -4139,6 +4145,11 @@ var createStrategyRuntime = ({
     const projectConfig = await loadTradejsConfig(projectRoot);
     const projectHooks = projectConfig.hooks;
     const env = String(config.ENV ?? "BACKTEST");
+    const jev = parseJevConfig(config.JEV);
+    if (jev && env !== "BACKTEST" && jev.source === "provider" && !jev.provider)
+      throw new Error(
+        "Runtime JEV requires a frozen provider endpoint and model"
+      );
     const backtestPriceMode = config.BACKTEST_PRICE_MODE ?? "open";
     const backtestEntryDelayBars = env === "BACKTEST" ? resolveBacktestEntryDelayBars(config.BACKTEST_ENTRY_DELAY_BARS) : 0;
     const resolvedBacktestExecutionInterval = config.BACKTEST_EXECUTION_INTERVAL ?? backtestExecutionMarketData?.interval ?? resolveBacktestExecutionIntervalForPrimary(config.INTERVAL ?? "15");
@@ -4846,6 +4857,16 @@ var createStrategyRuntime = ({
             env,
             includeHyperliquidWhales: false
           });
+          if (jev) {
+            await assessSignalWithJev({
+              signal,
+              config: jev,
+              userName,
+              projectRoot,
+              strict: env === "BACKTEST",
+              scope: runtimeLineage?.deploymentCompositionId ?? (env === "BACKTEST" ? "backtest" : "runtime")
+            });
+          }
           quality = await enrichSignalWithAi({
             signal,
             userName,
@@ -4915,6 +4936,7 @@ var createStrategyRuntime = ({
       if (!shouldMakeOrder) {
         if (signal) {
           const skipReason = getEntrySkipReason({
+            signal,
             makeOrdersEnabled,
             env,
             ml,