@tradejs/cli 3.1.28 → 3.1.29-beta.260

package/dist/lib/jevResearch.js

@@ -0,0 +1,229 @@
+"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 __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/lib/jevResearch.ts
+var jevResearch_exports = {};
+__export(jevResearch_exports, {
+  readJevJsonl: () => readJevJsonl,
+  runJevResearch: () => runJevResearch
+});
+module.exports = __toCommonJS(jevResearch_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_node_fs = require("fs");
+var import_node_readline = __toESM(require("readline"));
+var import_node_path = __toESM(require("path"));
+var import_node_crypto = require("crypto");
+var import_jev = require("@tradejs/infra/jev");
+var import_jev2 = require("@tradejs/node/jev");
+var readJevJsonl = async (file) => {
+  const rows = [];
+  const stream = (0, import_node_fs.createReadStream)(file);
+  const reader = import_node_readline.default.createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  try {
+    for await (const line of reader) {
+      if (!line.trim()) continue;
+      if (rows.length >= 2e4)
+        throw new Error("Select at most 20000 rows for this bounded Jev study");
+      rows.push(JSON.parse(line));
+    }
+  } finally {
+    reader.close();
+    stream.destroy();
+  }
+  return rows;
+};
+var writeNew = async (file, contents) => {
+  await import_promises.default.mkdir(import_node_path.default.dirname(file), { recursive: true });
+  await import_promises.default.writeFile(file, contents, { flag: "wx", mode: 384 });
+};
+var runJevResearch = async (options) => {
+  const resolve = (file) => import_node_path.default.resolve(options.projectRoot, file);
+  const out = resolve(options.out);
+  try {
+    await import_promises.default.access(out);
+    throw new Error("Jev output already exists; choose a new output path");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (options.action === "evaluate") {
+    if (!options.input)
+      throw new Error("Provide an AI dataset JSONL with --input");
+    const rows2 = await readJevJsonl(resolve(options.input));
+    const selected = rows2.filter(
+      (row) => !options.strategy || row.strategyName === options.strategy
+    );
+    if (!selected.length) throw new Error("No matching Jev input rows");
+    for (const row of selected) {
+      if (!row.assessment?.recordId)
+        throw new Error(
+          `Signal ${row.signalId} has no Jev recording. Run the backtest with --ai --jev and use its --jevRecordsDir; an --ai-only export cannot restore the signal-time Jev facts.`
+        );
+      if (!/^[a-f0-9]{64}$/.test(row.assessment.recordId))
+        throw new Error(`Invalid Jev recording id for signal ${row.signalId}`);
+    }
+    await import_promises.default.mkdir(import_node_path.default.dirname(out), { recursive: true });
+    const temp = `${out}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+    try {
+      const handle = await import_promises.default.open(temp, "wx", 384);
+      try {
+        for (const row of selected) {
+          const recordId = row.assessment.recordId;
+          const saved = await (0, import_jev.readJevArtifact)(
+            resolve(
+              import_node_path.default.join(options.recordsDir, "records", `${recordId}.json`)
+            )
+          );
+          if (!saved)
+            throw new Error(
+              `Jev recording ${recordId} for signal ${row.signalId} is missing from --jevRecordsDir. Use the recordings from the original --ai --jev backtest.`
+            );
+          if (saved.schema !== "tradejs-jev-record/v4")
+            throw new Error(
+              `Jev recording ${recordId} uses an older schema; rerun the backtest with the current --jev integration.`
+            );
+          if (saved.id !== recordId || saved.inputHash !== row.assessment?.inputHash || saved.questionsHash !== row.assessment?.questionsHash)
+            throw new Error(
+              `Jev recording ${recordId} does not match signal ${row.signalId}`
+            );
+          const { record } = await (0, import_jev2.evaluateJevInput)({
+            input: saved.input,
+            config: {
+              source: "recorded",
+              mode: "observe",
+              provider: saved.provider,
+              recordsDir: options.recordsDir
+            },
+            userName: options.userName,
+            projectRoot: options.projectRoot
+          });
+          if (!record)
+            throw new Error(
+              `No eligible Jev questions for signal ${row.signalId}`
+            );
+          const study = {
+            schema: "tradejs-jev-study/v4",
+            signalId: row.signalId,
+            record,
+            ...Number.isFinite(row.profit) ? { profit: row.profit } : {}
+          };
+          await handle.write(`${JSON.stringify(study)}
+`);
+        }
+      } finally {
+        await handle.close();
+      }
+      await import_promises.default.link(temp, out);
+    } finally {
+      await import_promises.default.rm(temp, { force: true });
+    }
+    return { rows: selected.length, out };
+  }
+  if (options.action === "export") {
+    const dir = resolve(import_node_path.default.join(options.recordsDir, "records"));
+    const rows2 = [];
+    const outcomes = options.input ? await readJevJsonl(resolve(options.input)) : [];
+    const byRecord = /* @__PURE__ */ new Map();
+    for (const row of outcomes) {
+      const id = row.assessment?.recordId;
+      if (!id) continue;
+      if (!/^[a-f0-9]{64}$/.test(id))
+        throw new Error("Invalid Jev recording id");
+      const prior = byRecord.get(id);
+      if (prior && (prior.profit !== row.profit || prior.signalId !== row.signalId))
+        throw new Error("Conflicting outcomes for one Jev recording");
+      byRecord.set(id, row);
+    }
+    for (const file of (await import_promises.default.readdir(dir)).filter((name) => /^[a-f0-9]{64}\.json$/.test(name)).sort()) {
+      const record = await (0, import_jev.readJevArtifact)(import_node_path.default.join(dir, file));
+      if (!record || options.strategy && record.input.strategy !== options.strategy)
+        continue;
+      if (rows2.length >= 2e4)
+        throw new Error(
+          "Export exceeds 20000 samples; select a bounded recording directory"
+        );
+      const outcome = byRecord.get(record.id);
+      rows2.push({
+        schema: "tradejs-jev-study/v4",
+        signalId: outcome?.signalId ?? record.id,
+        record,
+        ...outcome && Number.isFinite(outcome.profit) ? { profit: outcome.profit } : {}
+      });
+    }
+    if (!rows2.length) throw new Error("No Jev recordings to export");
+    await writeNew(
+      out,
+      rows2.map((row) => JSON.stringify(row)).join("\n") + "\n"
+    );
+    return { rows: rows2.length, out };
+  }
+  if (!options.input) throw new Error("Provide a Jev study JSONL with --input");
+  const rows = await readJevJsonl(resolve(options.input));
+  if (options.action === "train") {
+    const { model, report } = (0, import_jev2.trainJevGate)(rows, options);
+    const contents = `${JSON.stringify(model, null, 2)}
+`;
+    await writeNew(
+      `${out}.report.json`,
+      `${JSON.stringify(report, null, 2)}
+`
+    );
+    await writeNew(out, contents);
+    return {
+      model: out,
+      modelSha256: (0, import_jev.jevFileHash)(contents),
+      report: `${out}.report.json`,
+      trainEnd: model.training.trainEnd,
+      validationEnd: model.training.validationEnd
+    };
+  }
+  if (options.action === "compare") {
+    if (!options.model) throw new Error("Provide --model");
+    const model = (0, import_jev2.validateJevGateModel)(
+      JSON.parse(await import_promises.default.readFile(resolve(options.model), "utf8"))
+    );
+    const heldOut = rows.filter(
+      (row) => row.record.input.timestamp > model.training.validationEnd
+    );
+    if (!heldOut.length)
+      throw new Error("No held-out rows after model validationEnd");
+    const report = (0, import_jev2.compareJevGate)(model, heldOut);
+    await writeNew(out, `${JSON.stringify(report, null, 2)}
+`);
+    return report;
+  }
+  throw new Error("Jev action must be evaluate, export, train, or compare");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readJevJsonl,
+  runJevResearch
+});

package/dist/lib/runtimeEvidenceCompositions.js

@@ -402,7 +402,14 @@ var discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
 };
 
 // src/lib/runtimeEvidenceCompositions.ts
-var stableSnapshotIdentity = (deployment) => JSON.stringify({ ...deployment, tickers: void 0 });
+var stableSnapshotIdentity = (deployment) => JSON.stringify({
+  ...deployment,
+  tickers: void 0,
+  strategies: deployment.strategies.map((strategy) => ({
+    ...strategy,
+    controlState: void 0
+  }))
+});
 var producerIdentity = (producer) => JSON.stringify(producer);
 var loadRuntimeEvidenceCompositionSnapshots = async ({
   publishRoot,

package/dist/scripts/backtest.js

@@ -65,6 +65,52 @@ var import_data = require("@tradejs/core/data");
 var import_redis5 = require("@tradejs/infra/redis");
 var import_constants6 = require("@tradejs/core/constants");
 
+// src/lib/backtest/jevOptions.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_jev = require("@tradejs/core/jev");
+var import_jev2 = require("@tradejs/infra/jev");
+var import_userSettings = require("@tradejs/infra/userSettings");
+var import_jev3 = require("@tradejs/node/jev");
+var resolveBacktestAiExportEnabled = (flags2) => Boolean(flags2.ai);
+var resolveBacktestJev = async (flags2, userName2, projectRoot2) => {
+  if (!flags2.jev) {
+    if (flags2.jevRecorded || flags2.jevModelFile)
+      throw new Error("Jev options require --jev");
+    return void 0;
+  }
+  if (flags2.jevRecorded && flags2.jevModelFile)
+    throw new Error("Choose --jevRecorded or --jevModelFile");
+  const common = {
+    mode: "observe",
+    recordsDir: String(flags2.jevRecordsDir || "data/ai/jev")
+  };
+  if (flags2.jevModelFile) {
+    const modelFile = String(flags2.jevModelFile);
+    const contents = await import_promises.default.readFile(
+      import_node_path.default.resolve(projectRoot2, modelFile),
+      "utf8"
+    );
+    (0, import_jev3.validateJevGateModel)(JSON.parse(contents));
+    return (0, import_jev.parseJevConfig)({
+      ...common,
+      source: "local",
+      modelFile,
+      modelSha256: (0, import_jev2.jevFileHash)(contents)
+    });
+  }
+  const settings = flags2.jevRecorded ? await (0, import_userSettings.getUserSettings)(userName2) : null;
+  const provider = settings ? {
+    endpoint: settings.JEV_API_ENDPOINT || import_jev.JEV_PROVIDERS[0].endpoint,
+    model: settings.JEV_MODEL || import_jev.JEV_PROVIDERS[0].model
+  } : await (0, import_jev3.resolveJevProvider)(userName2);
+  return (0, import_jev.parseJevConfig)({
+    ...common,
+    source: flags2.jevRecorded ? "recorded" : "provider",
+    provider
+  });
+};
+
 // src/lib/backtest/runnerCore.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
@@ -906,7 +952,7 @@ var import_constants = require("@tradejs/core/constants");
 var import_indicators = require("@tradejs/core/indicators");
 var import_derivatives = require("@tradejs/infra/timescale/derivatives");
 var import_client2 = require("@tradejs/infra/timescale/client");
-var import_userSettings = require("@tradejs/infra/userSettings");
+var import_userSettings2 = require("@tradejs/infra/userSettings");
 var HOUR_MS = 60 * 60 * 1e3;
 var DAY_MS2 = 24 * HOUR_MS;
 var DEFAULT_LOOKBACK_HOURS = 48;
@@ -1142,7 +1188,7 @@ var extendEdges = (current, fromMs, toMs) => ({
   max: current?.max == null ? toMs : Math.max(current.max, Math.trunc(toMs))
 });
 var getCoinalyzeApiKey = async (userName2) => {
-  const settings = await (0, import_userSettings.getUserSettings)(userName2);
+  const settings = await (0, import_userSettings2.getUserSettings)(userName2);
   return settings.COINALYZE_API_KEY.trim() || String(process.env.COINALYZE_API_KEY ?? "").trim();
 };
 var getCoinalyzeBaseUrl = () => process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
@@ -1881,7 +1927,7 @@ var import_chalk3 = __toESM(require("chalk"));
 var import_async2 = require("@tradejs/core/async");
 var import_marketContext2 = require("@tradejs/infra/timescale/marketContext");
 var import_client3 = require("@tradejs/infra/timescale/client");
-var import_userSettings2 = require("@tradejs/infra/userSettings");
+var import_userSettings3 = require("@tradejs/infra/userSettings");
 var DAY_MS3 = 864e5;
 var DEFAULT_CONTEXT_MAX_AGE_MS = 48 * 60 * 6e4;
 var DEFAULT_FEAR_GREED_STALE_RETRY_MS = 60 * 6e4;
@@ -2105,27 +2151,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-var getCoinMarketCapPathLabel = (path3) => {
-  if (path3.includes("global-metrics")) return "global";
-  if (path3.includes("cryptocurrency/quotes")) return "reference";
-  if (path3.includes("exchange/quotes")) return "exchangeLiquidity";
-  if (path3.includes("fear-and-greed")) return "fearGreed";
-  if (path3.includes("cmc100")) return "cmc100";
-  if (path3.includes("cmc20")) return "cmc20";
-  return path3;
-};
-var recordCoinMarketCapFetchStats = (stats, path3, creditCount) => {
+var getCoinMarketCapPathLabel = (path4) => {
+  if (path4.includes("global-metrics")) return "global";
+  if (path4.includes("cryptocurrency/quotes")) return "reference";
+  if (path4.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path4.includes("fear-and-greed")) return "fearGreed";
+  if (path4.includes("cmc100")) return "cmc100";
+  if (path4.includes("cmc20")) return "cmc20";
+  return path4;
+};
+var recordCoinMarketCapFetchStats = (stats, path4, creditCount) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path3) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path4) ?? { requests: 0, credits: 0 };
   existing.requests += 1;
   existing.credits += creditCount ?? 0;
   stats.requests += 1;
   stats.totalCredits += creditCount ?? 0;
-  stats.byPath.set(path3, existing);
+  stats.byPath.set(path4, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path3, item]) => `${getCoinMarketCapPathLabel(path3)}=${item.requests}req/${item.credits}cr`
+    ([path4, item]) => `${getCoinMarketCapPathLabel(path4)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -2698,7 +2744,7 @@ var backfillCoinMarketCapContext = async (params) => {
     );
     return skippedResult(true);
   }
-  const settings = await (0, import_userSettings2.getUserSettings)(params.userName);
+  const settings = await (0, import_userSettings3.getUserSettings)(params.userName);
   const apiKey = settings.COINMARKETCAP_API_KEY.trim();
   if (!apiKey) {
     throw new Error(
@@ -4262,6 +4308,18 @@ import_args.default.option(
   "Write AI prompt rows to per-worker JSONL chunks",
   false
 );
+import_args.default.option("jev", "Enrich backtest signals with Jev assessments", false);
+import_args.default.option(
+  ["Q", "jevRecorded"],
+  "Use recorded Jev answers only; fail on a missing answer",
+  false
+);
+import_args.default.option(["M", "jevModelFile"], "Use a trained local Jev gate JSON file");
+import_args.default.option(
+  ["W", "jevRecordsDir"],
+  "Jev answer and decision directory",
+  "data/ai/jev"
+);
 import_args.default.option(
   "fast",
   "Skip per-test artifact persistence and keep only in-memory summary/AI-ML dataset output",
@@ -5095,7 +5153,8 @@ var buildPreparedTestSuite = async ({
   const executionCosts = flags.executionCosts == null ? void 0 : (0, import_backtest2.parseBacktestExecutionCosts)(JSON.parse(String(flags.executionCosts)));
   for (const test of testSuite)
     (0, import_backtest2.assertStrategyExecutionIsolation)(test.strategyConfig);
-  const aiEnabled = Boolean(flags.ai);
+  const jev = await resolveBacktestJev(flags, userName, projectRoot);
+  const aiEnabled = resolveBacktestAiExportEnabled(flags);
   const requestedTestsLimit = resolveRequestedTestsLimit({
     isLiveMode: isReplay,
     requestedLimit: testsLimit,
@@ -5108,6 +5167,7 @@ var buildPreparedTestSuite = async ({
     executionCostsCacheOnly: Boolean(flags.cacheOnly),
     strategyConfig: {
       ...test.strategyConfig,
+      JEV: jev,
       ENV: "BACKTEST",
       INTERVAL: interval,
       MAKE_ORDERS: true,
@@ -5770,7 +5830,8 @@ var backtest = async () => {
     window: preparedRun.window,
     preloadStart: preparedRun.preloadStart,
     flags: {
-      ai: Boolean(flags.ai),
+      ai: Boolean(flags.ai || flags.jev),
+      jev: Boolean(flags.jev),
       backtestEntryDelayBars,
       backtestPriceMode,
       cacheOnly: Boolean(flags.cacheOnly),

package/dist/scripts/jev.js

@@ -0,0 +1,269 @@
+"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 __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/scripts/jev.ts
+var jev_exports = {};
+__export(jev_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(jev_exports);
+var import_args = __toESM(require("args"));
+
+// src/lib/jevResearch.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_fs = require("fs");
+var import_node_readline = __toESM(require("readline"));
+var import_node_path = __toESM(require("path"));
+var import_node_crypto = require("crypto");
+var import_jev = require("@tradejs/infra/jev");
+var import_jev2 = require("@tradejs/node/jev");
+var readJevJsonl = async (file) => {
+  const rows = [];
+  const stream = (0, import_node_fs.createReadStream)(file);
+  const reader = import_node_readline.default.createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  try {
+    for await (const line of reader) {
+      if (!line.trim()) continue;
+      if (rows.length >= 2e4)
+        throw new Error("Select at most 20000 rows for this bounded Jev study");
+      rows.push(JSON.parse(line));
+    }
+  } finally {
+    reader.close();
+    stream.destroy();
+  }
+  return rows;
+};
+var writeNew = async (file, contents) => {
+  await import_promises.default.mkdir(import_node_path.default.dirname(file), { recursive: true });
+  await import_promises.default.writeFile(file, contents, { flag: "wx", mode: 384 });
+};
+var runJevResearch = async (options) => {
+  const resolve = (file) => import_node_path.default.resolve(options.projectRoot, file);
+  const out = resolve(options.out);
+  try {
+    await import_promises.default.access(out);
+    throw new Error("Jev output already exists; choose a new output path");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (options.action === "evaluate") {
+    if (!options.input)
+      throw new Error("Provide an AI dataset JSONL with --input");
+    const rows2 = await readJevJsonl(resolve(options.input));
+    const selected = rows2.filter(
+      (row) => !options.strategy || row.strategyName === options.strategy
+    );
+    if (!selected.length) throw new Error("No matching Jev input rows");
+    for (const row of selected) {
+      if (!row.assessment?.recordId)
+        throw new Error(
+          `Signal ${row.signalId} has no Jev recording. Run the backtest with --ai --jev and use its --jevRecordsDir; an --ai-only export cannot restore the signal-time Jev facts.`
+        );
+      if (!/^[a-f0-9]{64}$/.test(row.assessment.recordId))
+        throw new Error(`Invalid Jev recording id for signal ${row.signalId}`);
+    }
+    await import_promises.default.mkdir(import_node_path.default.dirname(out), { recursive: true });
+    const temp = `${out}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+    try {
+      const handle = await import_promises.default.open(temp, "wx", 384);
+      try {
+        for (const row of selected) {
+          const recordId = row.assessment.recordId;
+          const saved = await (0, import_jev.readJevArtifact)(
+            resolve(
+              import_node_path.default.join(options.recordsDir, "records", `${recordId}.json`)
+            )
+          );
+          if (!saved)
+            throw new Error(
+              `Jev recording ${recordId} for signal ${row.signalId} is missing from --jevRecordsDir. Use the recordings from the original --ai --jev backtest.`
+            );
+          if (saved.schema !== "tradejs-jev-record/v4")
+            throw new Error(
+              `Jev recording ${recordId} uses an older schema; rerun the backtest with the current --jev integration.`
+            );
+          if (saved.id !== recordId || saved.inputHash !== row.assessment?.inputHash || saved.questionsHash !== row.assessment?.questionsHash)
+            throw new Error(
+              `Jev recording ${recordId} does not match signal ${row.signalId}`
+            );
+          const { record } = await (0, import_jev2.evaluateJevInput)({
+            input: saved.input,
+            config: {
+              source: "recorded",
+              mode: "observe",
+              provider: saved.provider,
+              recordsDir: options.recordsDir
+            },
+            userName: options.userName,
+            projectRoot: options.projectRoot
+          });
+          if (!record)
+            throw new Error(
+              `No eligible Jev questions for signal ${row.signalId}`
+            );
+          const study = {
+            schema: "tradejs-jev-study/v4",
+            signalId: row.signalId,
+            record,
+            ...Number.isFinite(row.profit) ? { profit: row.profit } : {}
+          };
+          await handle.write(`${JSON.stringify(study)}
+`);
+        }
+      } finally {
+        await handle.close();
+      }
+      await import_promises.default.link(temp, out);
+    } finally {
+      await import_promises.default.rm(temp, { force: true });
+    }
+    return { rows: selected.length, out };
+  }
+  if (options.action === "export") {
+    const dir = resolve(import_node_path.default.join(options.recordsDir, "records"));
+    const rows2 = [];
+    const outcomes = options.input ? await readJevJsonl(resolve(options.input)) : [];
+    const byRecord = /* @__PURE__ */ new Map();
+    for (const row of outcomes) {
+      const id = row.assessment?.recordId;
+      if (!id) continue;
+      if (!/^[a-f0-9]{64}$/.test(id))
+        throw new Error("Invalid Jev recording id");
+      const prior = byRecord.get(id);
+      if (prior && (prior.profit !== row.profit || prior.signalId !== row.signalId))
+        throw new Error("Conflicting outcomes for one Jev recording");
+      byRecord.set(id, row);
+    }
+    for (const file of (await import_promises.default.readdir(dir)).filter((name) => /^[a-f0-9]{64}\.json$/.test(name)).sort()) {
+      const record = await (0, import_jev.readJevArtifact)(import_node_path.default.join(dir, file));
+      if (!record || options.strategy && record.input.strategy !== options.strategy)
+        continue;
+      if (rows2.length >= 2e4)
+        throw new Error(
+          "Export exceeds 20000 samples; select a bounded recording directory"
+        );
+      const outcome = byRecord.get(record.id);
+      rows2.push({
+        schema: "tradejs-jev-study/v4",
+        signalId: outcome?.signalId ?? record.id,
+        record,
+        ...outcome && Number.isFinite(outcome.profit) ? { profit: outcome.profit } : {}
+      });
+    }
+    if (!rows2.length) throw new Error("No Jev recordings to export");
+    await writeNew(
+      out,
+      rows2.map((row) => JSON.stringify(row)).join("\n") + "\n"
+    );
+    return { rows: rows2.length, out };
+  }
+  if (!options.input) throw new Error("Provide a Jev study JSONL with --input");
+  const rows = await readJevJsonl(resolve(options.input));
+  if (options.action === "train") {
+    const { model, report } = (0, import_jev2.trainJevGate)(rows, options);
+    const contents = `${JSON.stringify(model, null, 2)}
+`;
+    await writeNew(
+      `${out}.report.json`,
+      `${JSON.stringify(report, null, 2)}
+`
+    );
+    await writeNew(out, contents);
+    return {
+      model: out,
+      modelSha256: (0, import_jev.jevFileHash)(contents),
+      report: `${out}.report.json`,
+      trainEnd: model.training.trainEnd,
+      validationEnd: model.training.validationEnd
+    };
+  }
+  if (options.action === "compare") {
+    if (!options.model) throw new Error("Provide --model");
+    const model = (0, import_jev2.validateJevGateModel)(
+      JSON.parse(await import_promises.default.readFile(resolve(options.model), "utf8"))
+    );
+    const heldOut = rows.filter(
+      (row) => row.record.input.timestamp > model.training.validationEnd
+    );
+    if (!heldOut.length)
+      throw new Error("No held-out rows after model validationEnd");
+    const report = (0, import_jev2.compareJevGate)(model, heldOut);
+    await writeNew(out, `${JSON.stringify(report, null, 2)}
+`);
+    return report;
+  }
+  throw new Error("Jev action must be evaluate, export, train, or compare");
+};
+
+// src/scripts/jev.ts
+import_args.default.option(
+  "action",
+  "Jev workflow: evaluate recorded rows, export, train, compare"
+);
+import_args.default.option(
+  "input",
+  "Input JSONL; export optionally joins outcomes by exact assessment record"
+);
+import_args.default.option("out", "New output file (existing files are never overwritten)");
+import_args.default.option("user", "Account settings user", "root");
+import_args.default.option("strategy", "Select one strategy");
+import_args.default.option("recordsDir", "Jev recordings directory", "data/ai/jev");
+import_args.default.option("model", "Local Jev gate JSON for comparison");
+import_args.default.option("maxDepth", "Maximum local rule tree depth", 3);
+import_args.default.option(["l", "minLeaf"], "Minimum training samples per leaf", 10);
+var main = async () => {
+  const flags = import_args.default.parse(process.argv);
+  if (!flags.out) throw new Error("Provide --out for the immutable Jev result");
+  console.log(
+    JSON.stringify(
+      await runJevResearch({
+        action: String(flags.action),
+        projectRoot: process.env.PROJECT_CWD || process.cwd(),
+        userName: String(flags.user),
+        input: flags.input,
+        out: String(flags.out),
+        strategy: flags.strategy,
+        recordsDir: String(flags.recordsDir),
+        model: flags.model,
+        maxDepth: Number(flags.maxDepth),
+        minLeaf: Number(flags.minLeaf)
+      }),
+      null,
+      2
+    )
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});