@tradejs/cli 2.0.20 → 3.0.0

package/dist/scripts/aiTrain.js

@@ -43,6 +43,7 @@ var import_ai = require("@tradejs/infra/ai");
 var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 var import_redis = require("@tradejs/infra/redis");
 var import_ai2 = require("@tradejs/node/ai");
+var import_registry = require("@tradejs/node/registry");
 var import_constants2 = require("@tradejs/node/constants");
 
 // src/lib/aiTrainMetrics.ts
@@ -920,6 +921,38 @@ var parseTerminalWindowDays = (value) => {
   const raw = String(value ?? "90,30,7").split(",").map((part) => Number(part.trim())).filter((part) => Number.isFinite(part)).map((part) => Math.trunc(part)).filter((part) => part > 0);
   return [...new Set(raw)].sort((left, right) => right - left);
 };
+var parseAiTrainDirectionPolicy = (value) => {
+  const normalized = String(value ?? "both").trim().toLowerCase().replaceAll("-", "_");
+  if (normalized === "both" || normalized === "long_only" || normalized === "short_only" || normalized === "direction_aware") {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid --directionPolicy value "${String(value)}". Use both, long_only, short_only, or direction_aware.`
+  );
+};
+var assertAiTrainDirectionPolicy = ({
+  directionPolicy,
+  byDirection,
+  terminalWindows
+}) => {
+  const suppressedDirection = directionPolicy === "long_only" ? "SHORT" : directionPolicy === "short_only" ? "LONG" : null;
+  if (!suppressedDirection) return;
+  for (const scope of [{ label: "full", byDirection }, ...terminalWindows]) {
+    const summary = scope.byDirection.find(
+      (entry) => entry.direction === suppressedDirection
+    );
+    if (!summary) {
+      throw new Error(
+        `${scope.label} ${suppressedDirection} direction summary is required for ${directionPolicy}`
+      );
+    }
+    if (summary.summary.approved !== 0) {
+      throw new Error(
+        `${scope.label} has ${summary.summary.approved} ${suppressedDirection} approved rows under ${directionPolicy}`
+      );
+    }
+  }
+};
 var parseDumpFeatureMode = (value) => {
   const text = String(value ?? "none").trim().toLowerCase();
   if (!text || text === "none" || text === "false" || text === "0") {
@@ -1416,6 +1449,11 @@ import_args.default.option(
   "Minimum AI quality required to approve entry",
   4
 );
+import_args.default.option(
+  ["Y", "directionPolicy"],
+  "Evidence label for the enforced gate policy: both, long_only, short_only, or direction_aware",
+  "both"
+);
 import_args.default.option(
   ["l", "localOnly"],
   "Replay deterministic adapter gate without AI provider calls",
@@ -1806,6 +1844,7 @@ var main = async () => {
   });
   const qualityThresholds = parseQualityThresholds(flags.qualityThresholds);
   const terminalWindowDays = parseTerminalWindowDays(flags.terminalWindows);
+  const directionPolicy = parseAiTrainDirectionPolicy(flags.directionPolicy);
   const dumpEvaluationsPath = String(flags.dumpEvaluations || "").trim();
   const dumpFeatureMode = parseDumpFeatureMode(flags.dumpFeatures);
   if (dumpFeatureMode !== "none" && !dumpEvaluationsPath) {
@@ -1827,7 +1866,7 @@ var main = async () => {
   const userName = String(flags.user || "root").trim() || "root";
   const model = String(flags.model || import_ai2.DEFAULT_AI_MODEL).trim() || import_ai2.DEFAULT_AI_MODEL;
   const parallel = normalizePositiveInt(flags.parallel, import_constants2.AI_CONCURRENCY_LIMIT);
-  await (0, import_ai2.ensureAiStrategyPluginsLoaded)();
+  await (0, import_registry.ensureStrategyPluginsLoaded)();
   const filePaths = await resolveDatasetFiles();
   const datasetId = getMergedGroupId(filePaths[0] || "")?.mergeId;
   const { totalRows, selectedRows } = await (0, import_ai.countAiDatasetRows)({
@@ -2020,18 +2059,29 @@ var main = async () => {
     finalEvaluations,
     terminalWindowDays
   );
-  const topRejectReasons = summarizeAiTrainRejectReasons(finalEvaluations);
-  const lineage = await buildAiTrainLineage({
-    projectRoot: String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
-    strategyName,
-    configIds: finalEvaluations.map((evaluation) => evaluation.configId),
-    sourceSha256s: await Promise.all(filePaths.map(import_strategyReleaseEvidence.strategyEvidenceFileSha256)),
-    runContext: {
-      mode: localOnly ? "local-deterministic" : "llm",
-      model: localOnly ? "local-deterministic" : model,
-      minQuality
-    }
+  assertAiTrainDirectionPolicy({
+    directionPolicy,
+    byDirection: directionSummaries,
+    terminalWindows
   });
+  const topRejectReasons = summarizeAiTrainRejectReasons(finalEvaluations);
+  const lineage = {
+    ...await buildAiTrainLineage({
+      projectRoot: String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
+      strategyName,
+      configIds: finalEvaluations.map((evaluation) => evaluation.configId),
+      sourceSha256s: await Promise.all(
+        filePaths.map(import_strategyReleaseEvidence.strategyEvidenceFileSha256)
+      ),
+      runContext: {
+        mode: localOnly ? "local-deterministic" : "llm",
+        model: localOnly ? "local-deterministic" : model,
+        minQuality,
+        directionPolicy
+      }
+    }),
+    directionPolicy
+  };
   const evaluated = summary.correct + summary.incorrect;
   const result = {
     run: {
@@ -2053,7 +2103,8 @@ var main = async () => {
       model: localOnly ? "local-deterministic" : model,
       parallel: concurrency,
       dumpFeatures: dumpFeatureMode,
-      terminalWindows: terminalWindowDays
+      terminalWindows: terminalWindowDays,
+      directionPolicy
     },
     outcome: summary,
     byDirection: directionSummaries,

package/dist/scripts/coreResearch.js

@@ -1504,6 +1504,7 @@ var normalizeCompletedTrade = (params) => {
     runId: row.backtestRunId ?? null,
     configId: row.configId?.trim() || "<missing-config-id>",
     signalId,
+    positionCycleId: typeof result.positionCycleId === "string" && result.positionCycleId.trim() ? result.positionCycleId.trim() : null,
     setupIdentity,
     setupIdentitySource: explicitIdentity ? "research.setupIdentity" : strategyIdentity ? "strategy-context" : "signal-time-fallback",
     strategy: row.strategyName,
@@ -1527,6 +1528,69 @@ var normalizeCompletedTrade = (params) => {
   };
 };
 var completedTradeIdentity = (trade) => [trade.runId ?? "", trade.configId, trade.signalId, trade.symbol].join("|");
+var positionCycleIdentity = (trade) => trade.positionCycleId ? [
+  trade.runId ?? "",
+  trade.configId,
+  trade.strategy,
+  trade.symbol,
+  trade.direction,
+  trade.positionCycleId
+].join("|") : null;
+var sumBy = (trades, select) => trades.reduce((sum, trade) => sum + select(trade), 0);
+var weightedPrice = (trades, select) => {
+  const withPrice = trades.filter((trade) => select(trade) != null);
+  const qty = sumBy(withPrice, (trade) => trade.qty);
+  if (qty <= 0) return null;
+  return sumBy(withPrice, (trade) => Number(select(trade)) * trade.qty) / qty;
+};
+var aggregatePositionCycles = (trades) => {
+  const standalone = [];
+  const cycles = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const identity = positionCycleIdentity(trade);
+    if (!identity) {
+      standalone.push(trade);
+      continue;
+    }
+    const cycle = cycles.get(identity) ?? [];
+    cycle.push(trade);
+    cycles.set(identity, cycle);
+  }
+  for (const [identity, cycle] of cycles) {
+    const primaryRows = cycle.filter(
+      (trade) => trade.signalId === trade.positionCycleId
+    );
+    if (primaryRows.length !== 1) {
+      throw new Error(
+        `Position cycle ${identity} must contain exactly one opening row; found ${primaryRows.length}`
+      );
+    }
+    const primary = primaryRows[0];
+    if (cycle.some(
+      (trade) => trade.exitTimestamp !== primary.exitTimestamp || trade.exitReason !== primary.exitReason
+    )) {
+      throw new Error(
+        `Position cycle ${identity} contains inconsistent final exits`
+      );
+    }
+    if (cycle.length === 1) {
+      standalone.push(primary);
+      continue;
+    }
+    standalone.push({
+      ...primary,
+      entryTimestamp: Math.min(...cycle.map((trade) => trade.entryTimestamp)),
+      entryPrice: weightedPrice(cycle, (trade) => trade.entryPrice) ?? 0,
+      exitPrice: weightedPrice(cycle, (trade) => trade.exitPrice),
+      qty: sumBy(cycle, (trade) => trade.qty),
+      netProfit: sumBy(cycle, (trade) => trade.netProfit),
+      grossProfit: sumBy(cycle, (trade) => trade.grossProfit),
+      totalFee: sumBy(cycle, (trade) => trade.totalFee),
+      totalSlippageCost: sumBy(cycle, (trade) => trade.totalSlippageCost)
+    });
+  }
+  return standalone;
+};
 var compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 var compareTrades = (left, right) => left.exitTimestamp - right.exitTimestamp || compareText(left.symbol, right.symbol) || compareText(left.direction, right.direction) || compareText(left.signalId, right.signalId) || compareText(left.sourceFile, right.sourceFile) || left.sourceLine - right.sourceLine;
 var readCoreResearchVariant = async (variant) => {
@@ -1603,7 +1667,7 @@ var readCoreResearchVariant = async (variant) => {
     variant,
     files: sources,
     duplicateRowsDropped,
-    trades: trades.sort(compareTrades)
+    trades: aggregatePositionCycles(trades).sort(compareTrades)
   };
 };
 
@@ -2084,13 +2148,17 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   const loaded = await Promise.all(
     analysisSpec.variants.map(readCoreResearchVariant)
   );
+  const periodDays = (spec.window.end - spec.window.start) / DAY_MS;
   const windowed = loaded.map((entry) => ({
     ...entry,
+    reconciliationMetrics: summarizeCoreResearchCohorts(
+      entry.trades,
+      periodDays
+    ).ALL,
     trades: entry.trades.filter(
       (trade) => trade.exitTimestamp >= spec.window.start && trade.exitTimestamp < spec.window.end
     )
   }));
-  const periodDays = (spec.window.end - spec.window.start) / DAY_MS;
   const analyses = await Promise.all(
     windowed.map(async (entry) => ({
       variant: entry.variant,
@@ -2148,12 +2216,9 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
       reconciliation: await reconcileCoreResearchVariant({
         variant: entry.variant,
         spec,
-        exportMetrics: summarizeCoreResearchWindow({
-          trades: entry.trades,
-          label: "full",
-          start: spec.window.start,
-          end: spec.window.end
-        }).cohorts.ALL
+        // Redis result.stat includes the runner's terminal close at window.end.
+        // Keep half-open research metrics, but reconcile the complete run export.
+        exportMetrics: entry.reconciliationMetrics
       }),
       supplemental: {
         coldStart: Object.fromEntries(

package/dist/scripts/replay.js

@@ -4906,6 +4906,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 var import_types2 = require("@tradejs/types");
 var import_strategies3 = require("@tradejs/node/strategies");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
@@ -5000,17 +5001,6 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var normalizeRuntimeLogicConfig = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeRuntimeLogicConfig);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([key]) => key !== "MAX_LOSS_VALUE").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeRuntimeLogicConfig(entry)])
-    );
-  }
-  return value;
-};
 var resolveRuntimeMaxLossValue = (config) => {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return null;
@@ -5174,9 +5164,7 @@ var buildRuntimeLineage = async ({
     })).gateFingerprint,
     // Position risk is tracked separately so changing trade size does not
     // masquerade as a change to the core + gate decision logic.
-    configFingerprint: fingerprintRuntimeValue(
-      normalizeRuntimeLogicConfig(config)
-    ),
+    configFingerprint: (0, import_strategyReleaseEvidence.strategyLogicConfigFingerprint)(config),
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };

package/dist/scripts/replayRunner.js

@@ -4909,6 +4909,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 var import_types2 = require("@tradejs/types");
 var import_strategies3 = require("@tradejs/node/strategies");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
@@ -5003,17 +5004,6 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var normalizeRuntimeLogicConfig = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeRuntimeLogicConfig);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([key]) => key !== "MAX_LOSS_VALUE").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeRuntimeLogicConfig(entry)])
-    );
-  }
-  return value;
-};
 var resolveRuntimeMaxLossValue = (config) => {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return null;
@@ -5177,9 +5167,7 @@ var buildRuntimeLineage = async ({
     })).gateFingerprint,
     // Position risk is tracked separately so changing trade size does not
     // masquerade as a change to the core + gate decision logic.
-    configFingerprint: fingerprintRuntimeValue(
-      normalizeRuntimeLogicConfig(config)
-    ),
+    configFingerprint: (0, import_strategyReleaseEvidence.strategyLogicConfigFingerprint)(config),
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };

package/dist/scripts/runtimeEvidence.js

@@ -564,6 +564,7 @@ var import_promises3 = __toESM(require("fs/promises"));
 var import_node_path3 = __toESM(require("path"));
 var import_types = require("@tradejs/types");
 var import_strategies = require("@tradejs/node/strategies");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto2 = require("crypto");

package/dist/scripts/runtimeScorecard.js

@@ -811,6 +811,7 @@ var deriveReleaseGates = (evidence) => {
   };
 };
 var verifyEvidenceComposition = (strategy, composition, evidence) => {
+  const directionPolicy = composition.directionPolicy ?? "both";
   const requireEqual = (actual, expected, label, artifactId) => assert(
     actual === expected,
     `evidence ${artifactId} ${label} does not match the frozen composition`
@@ -881,6 +882,14 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
         "gateContextFingerprint",
         reference.artifactId
       );
+      if (directionPolicy !== "both" || lineage?.directionPolicy != null) {
+        requireEqual(
+          lineage?.directionPolicy,
+          directionPolicy,
+          "directionPolicy",
+          reference.artifactId
+        );
+      }
       assert(
         lineage?.sourceSha256s.includes(composition.coreExportSha256),
         `evidence ${reference.artifactId} does not use the frozen core export`
@@ -925,6 +934,14 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
         "MAX_LOSS_VALUE",
         reference.artifactId
       );
+      if (directionPolicy !== "both" || lineage?.directionPolicy != null) {
+        requireEqual(
+          lineage?.directionPolicy,
+          directionPolicy,
+          "directionPolicy",
+          reference.artifactId
+        );
+      }
       continue;
     }
     if (reference.kind === "execution_calibration") {
@@ -965,6 +982,14 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
         "MAX_LOSS_VALUE",
         reference.artifactId
       );
+      if (directionPolicy !== "both" || lineage?.directionPolicy != null) {
+        requireEqual(
+          lineage?.directionPolicy,
+          directionPolicy,
+          "directionPolicy",
+          reference.artifactId
+        );
+      }
     }
   }
 };
@@ -1000,6 +1025,12 @@ var createStrategyReleaseManifest = (input) => {
     input.composition.longEnabled && input.composition.shortEnabled,
     "LONG and SHORT must both remain enabled"
   );
+  assert(
+    input.composition.directionPolicy == null || ["both", "long_only", "short_only", "direction_aware"].includes(
+      input.composition.directionPolicy
+    ),
+    "composition.directionPolicy is invalid"
+  );
   assert(
     Number.isInteger(input.monitoring.minimumProspectiveClosedTrades) && input.monitoring.minimumProspectiveClosedTrades > 0,
     "monitoring.minimumProspectiveClosedTrades must be positive"
@@ -1064,7 +1095,8 @@ var createStrategyReleaseManifest = (input) => {
     gateFingerprint: input.composition.gateFingerprint,
     gateContextFingerprint: input.composition.gateContextFingerprint,
     runtimeContextFingerprint: input.composition.runtimeContextFingerprint,
-    maxLossValue: input.composition.maxLossValue
+    maxLossValue: input.composition.maxLossValue,
+    ...input.composition.directionPolicy == null ? {} : { directionPolicy: input.composition.directionPolicy }
   };
   const compositionId = `${safeSegment2(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
   const reasons = releaseReasons({ ...input, gates: evidenceGates });
@@ -1148,7 +1180,8 @@ var verifyStrategyReleaseEnvelope = async (valueOrPath) => {
       runtimeContextFingerprint: manifest.composition.runtimeContextFingerprint,
       maxLossValue: manifest.composition.maxLossValue,
       longEnabled: manifest.composition.longEnabled,
-      shortEnabled: manifest.composition.shortEnabled
+      shortEnabled: manifest.composition.shortEnabled,
+      directionPolicy: manifest.composition.directionPolicy
     },
     marketWindow: manifest.marketWindow,
     researchBudget: manifest.researchBudget,

package/dist/scripts/signals.js

@@ -4003,6 +4003,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 var import_types = require("@tradejs/types");
 var import_strategies4 = require("@tradejs/node/strategies");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
@@ -4097,17 +4098,6 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var normalizeRuntimeLogicConfig = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeRuntimeLogicConfig);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([key]) => key !== "MAX_LOSS_VALUE").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeRuntimeLogicConfig(entry)])
-    );
-  }
-  return value;
-};
 var resolveRuntimeMaxLossValue = (config2) => {
   if (!config2 || typeof config2 !== "object" || Array.isArray(config2)) {
     return null;
@@ -4271,9 +4261,7 @@ var buildRuntimeLineage = async ({
     })).gateFingerprint,
     // Position risk is tracked separately so changing trade size does not
     // masquerade as a change to the core + gate decision logic.
-    configFingerprint: fingerprintRuntimeValue(
-      normalizeRuntimeLogicConfig(config2)
-    ),
+    configFingerprint: (0, import_strategyReleaseEvidence.strategyLogicConfigFingerprint)(config2),
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config2)
   };

package/dist/scripts/signalsDaemon.js

@@ -4001,6 +4001,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 var import_types = require("@tradejs/types");
 var import_strategies4 = require("@tradejs/node/strategies");
+var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
@@ -4095,17 +4096,6 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var normalizeRuntimeLogicConfig = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeRuntimeLogicConfig);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([key]) => key !== "MAX_LOSS_VALUE").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeRuntimeLogicConfig(entry)])
-    );
-  }
-  return value;
-};
 var resolveRuntimeMaxLossValue = (config2) => {
   if (!config2 || typeof config2 !== "object" || Array.isArray(config2)) {
     return null;
@@ -4269,9 +4259,7 @@ var buildRuntimeLineage = async ({
     })).gateFingerprint,
     // Position risk is tracked separately so changing trade size does not
     // masquerade as a change to the core + gate decision logic.
-    configFingerprint: fingerprintRuntimeValue(
-      normalizeRuntimeLogicConfig(config2)
-    ),
+    configFingerprint: (0, import_strategyReleaseEvidence.strategyLogicConfigFingerprint)(config2),
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config2)
   };