@tradejs/cli 2.0.20 → 3.0.0

package/dist/lib/aiTrainOptions.js

@@ -20,7 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/aiTrainOptions.ts
 var aiTrainOptions_exports = {};
 __export(aiTrainOptions_exports, {
+  assertAiTrainDirectionPolicy: () => assertAiTrainDirectionPolicy,
   hasCliOption: () => hasCliOption,
+  parseAiTrainDirectionPolicy: () => parseAiTrainDirectionPolicy,
   parseDumpFeatureMode: () => parseDumpFeatureMode,
   parseQualityThresholds: () => parseQualityThresholds,
   parseTerminalWindowDays: () => parseTerminalWindowDays,
@@ -81,6 +83,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") {
@@ -120,7 +154,9 @@ var resolveAiTrainRecentLimit = ({
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  assertAiTrainDirectionPolicy,
   hasCliOption,
+  parseAiTrainDirectionPolicy,
   parseDumpFeatureMode,
   parseQualityThresholds,
   parseTerminalWindowDays,

package/dist/lib/coreResearch.js

@@ -1513,6 +1513,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,
@@ -1536,6 +1537,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) => {
@@ -1612,7 +1676,7 @@ var readCoreResearchVariant = async (variant) => {
     variant,
     files: sources,
     duplicateRowsDropped,
-    trades: trades.sort(compareTrades)
+    trades: aggregatePositionCycles(trades).sort(compareTrades)
   };
 };
 
@@ -2093,13 +2157,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,
@@ -2157,12 +2225,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/lib/runtimeLineage.js

@@ -43,6 +43,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __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_crypto = require("crypto");
@@ -137,17 +138,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;
@@ -311,9 +301,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/lib/strategyRelease.js

@@ -81,6 +81,12 @@ var hasExactRuntimeTarget = (target) => Boolean(
 );
 var deriveStrategyReleaseResearchDecision = async (input) => {
   const blockers = [];
+  const directionPolicy = input.directionPolicy ?? "both";
+  const activeDirections = directionPolicy === "long_only" ? ["long"] : directionPolicy === "short_only" ? ["short"] : ["long", "short"];
+  const suppressedDirection = directionPolicy === "long_only" ? "short" : directionPolicy === "short_only" ? "long" : null;
+  const hasHistoricalEdge = (entry) => entry.pnl > 0 && entry.profitFactor >= 1 && activeDirections.every(
+    (direction) => entry[direction].pnl > 0 && entry[direction].profitFactor >= 1
+  ) && (suppressedDirection == null || entry[suppressedDirection].trades === 0 && entry[suppressedDirection].pnl === 0);
   const byDays = new Map(
     input.historicalWindows.map((entry) => [entry.days, entry])
   );
@@ -93,17 +99,13 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
   const longWindows = REQUIRED_LONG_WINDOWS.map(
     (days) => byDays.get(days)
   ).filter((entry) => Boolean(entry));
-  if (longWindows.some(
-    (entry) => entry.pnl <= 0 || entry.profitFactor < 1 || entry.long.pnl <= 0 || entry.long.profitFactor < 1 || entry.short.pnl <= 0 || entry.short.profitFactor < 1
-  )) {
+  if (longWindows.some((entry) => !hasHistoricalEdge(entry))) {
     blockers.push("HISTORICAL_EDGE_FAILED");
   }
   const stableTerminalWindows = REQUIRED_STABLE_TERMINAL_WINDOWS.map(
     (days) => byDays.get(days)
   ).filter((entry) => Boolean(entry));
-  if (stableTerminalWindows.some(
-    (entry) => entry.pnl <= 0 || entry.profitFactor < 1 || entry.long.pnl <= 0 || entry.long.profitFactor < 1 || entry.short.pnl <= 0 || entry.short.profitFactor < 1
-  )) {
+  if (stableTerminalWindows.some((entry) => !hasHistoricalEdge(entry))) {
     blockers.push("HISTORICAL_EDGE_FAILED");
   }
   if (blockers.length) {
@@ -113,8 +115,9 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
       repairAllowed: false,
       targetDirection: input.recentFailure?.direction ?? null,
       maxLossValue: null,
+      requiresRuntimeBinding: false,
       blockers,
-      summary: "The final composition does not have complete positive ALL/LONG/SHORT evidence on the frozen 3y/4y/max-window matrix."
+      summary: `The final ${directionPolicy} composition does not have complete positive evidence for ALL and every active direction on the frozen 3y/4y/max-window matrix.`
     };
   }
   const repairAllowed = Boolean(
@@ -127,6 +130,7 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
       repairAllowed: true,
       targetDirection: input.recentFailure.direction,
       maxLossValue: null,
+      requiresRuntimeBinding: false,
       blockers: [],
       summary: "Spend the single terminal-direction repair round on the preregistered causal mechanism, then rebuild the full evidence matrix."
     };
@@ -145,6 +149,7 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
       repairAllowed: false,
       targetDirection: input.recentFailure?.direction ?? null,
       maxLossValue: null,
+      requiresRuntimeBinding: false,
       blockers,
       summary: "Complete the frozen candidate implementation and full-period chart before any micro-forward execution."
     };
@@ -156,6 +161,9 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
       repairAllowed: false,
       targetDirection: input.recentFailure?.direction ?? null,
       maxLossValue: 1,
+      requiresRuntimeBinding: !hasExactRuntimeTarget(
+        input.forwardTest.runtimeTarget
+      ),
       blockers: ["FORWARD_NOT_AUTHORIZED"],
       summary: "The candidate is ready for a separately authorized micro-forward test at MAX_LOSS_VALUE=1."
     };
@@ -163,12 +171,13 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
   if (!hasExactRuntimeTarget(input.forwardTest.runtimeTarget)) {
     return {
       strategy: input.strategy,
-      action: "FORWARD_BLOCKED",
+      action: "MICRO_FORWARD_READY",
       repairAllowed: false,
       targetDirection: input.recentFailure?.direction ?? null,
       maxLossValue: 1,
-      blockers: ["RUNTIME_TARGET_UNRESOLVED"],
-      summary: "Forward testing is authorized, but an exact runtime deployment/account target must be resolved first."
+      requiresRuntimeBinding: true,
+      blockers: [],
+      summary: "The portable micro-forward handoff is ready. Bind it on the runtime server to that server's deployment/account ids and verify canonical composition fingerprints there."
     };
   }
   return {
@@ -177,6 +186,7 @@ var deriveStrategyReleaseResearchDecision = async (input) => {
     repairAllowed: false,
     targetDirection: input.recentFailure?.direction ?? null,
     maxLossValue: 1,
+    requiresRuntimeBinding: false,
     blockers: [],
     summary: "Start the exact frozen composition as a micro-forward test at MAX_LOSS_VALUE=1; do not retune an underpowered or exposed recent tail."
   };
@@ -234,6 +244,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`
@@ -304,6 +315,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`
@@ -348,6 +367,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") {
@@ -388,6 +415,14 @@ var verifyEvidenceComposition = (strategy, composition, evidence) => {
         "MAX_LOSS_VALUE",
         reference.artifactId
       );
+      if (directionPolicy !== "both" || lineage?.directionPolicy != null) {
+        requireEqual(
+          lineage?.directionPolicy,
+          directionPolicy,
+          "directionPolicy",
+          reference.artifactId
+        );
+      }
     }
   }
 };
@@ -423,6 +458,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"
@@ -487,7 +528,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 = `${safeSegment(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
   const reasons = releaseReasons({ ...input, gates: evidenceGates });
@@ -577,7 +619,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,
@@ -1001,6 +1044,7 @@ var finiteNumber = (value) => {
   const number = Number(value);
   return Number.isFinite(number) ? number : null;
 };
+var finiteDirectionPolicy = (value) => ["both", "long_only", "short_only", "direction_aware"].includes(String(value)) ? value : null;
 var uniqueStrings = (values) => [
   ...new Set(
     values.map(finiteString).filter((value) => value != null)
@@ -1017,6 +1061,7 @@ var incompleteEvidenceLineage = () => ({
   gateContextFingerprint: null,
   runtimeContextFingerprint: null,
   maxLossValue: null,
+  directionPolicy: null,
   sourceSha256s: []
 });
 var extractEvidenceLineage = ({
@@ -1079,6 +1124,7 @@ var extractEvidenceLineage = ({
       gateConfigIdsFingerprint: finiteString(lineage?.configIdsFingerprint),
       gateFingerprint: finiteString(lineage?.gateFingerprint),
       gateContextFingerprint: finiteString(lineage?.contextFingerprint),
+      directionPolicy: finiteDirectionPolicy(lineage?.directionPolicy),
       sourceSha256s: uniqueStrings(array(lineage?.sourceSha256s))
     };
   }
@@ -1114,7 +1160,8 @@ var extractEvidenceLineage = ({
       gateFingerprint: one("gateFingerprint"),
       runtimeConfigFingerprint: one("configFingerprint"),
       runtimeContextFingerprint: one("contextFingerprint"),
-      maxLossValue: maxLossValues.length === 1 ? maxLossValues[0] : null
+      maxLossValue: maxLossValues.length === 1 ? maxLossValues[0] : null,
+      directionPolicy: finiteDirectionPolicy(one("directionPolicy"))
     };
   }
   if (reference.kind === "execution_calibration") {
@@ -1151,6 +1198,7 @@ var extractEvidenceLineage = ({
       runtimeConfigFingerprint: one("configFingerprint"),
       runtimeContextFingerprint: one("contextFingerprint"),
       maxLossValue: maxLossValues.length === 1 ? maxLossValues[0] : null,
+      directionPolicy: finiteDirectionPolicy(one("directionPolicy")),
       sourceSha256s: uniqueStrings([
         ...array(nested(artifact.sources)?.sha256s),
         ...array(artifact.sourceSha256s)
@@ -1287,9 +1335,10 @@ async function collectReleaseEvidenceReferences(references) {
         if (reference.kind === "ai_gate") {
           const outcome = nested(artifact.outcome);
           const approvedRisk = nested(outcome?.approvedRisk);
-          const terminalWindows = array(
-            nested(artifact.research)?.terminalWindows
-          ).map(nested).filter((entry) => entry != null);
+          const run = nested(artifact.run);
+          const research = nested(artifact.research);
+          const researchLineage = nested(research?.lineage);
+          const terminalWindows = array(research?.terminalWindows).map(nested).filter((entry) => entry != null);
           const hasLongShortDirections = (value) => {
             const directions = new Map(
               array(value).map(nested).filter(
@@ -1303,6 +1352,22 @@ async function collectReleaseEvidenceReferences(references) {
           const directionalEvidenceComplete = hasLongShortDirections(artifact.byDirection) && terminalWindows.every(
             (window) => hasLongShortDirections(window.byDirection)
           );
+          const directionPolicy = finiteDirectionPolicy(researchLineage?.directionPolicy) ?? "both";
+          const runDirectionPolicy = finiteDirectionPolicy(run?.directionPolicy) ?? "both";
+          const suppressedDirection = directionPolicy === "long_only" ? "SHORT" : directionPolicy === "short_only" ? "LONG" : null;
+          const approvedForDirection = (value, direction) => {
+            const entry = array(value).map(nested).find((candidate) => candidate?.direction === direction);
+            return Number(nested(entry?.summary)?.approved ?? Number.NaN);
+          };
+          const directionPolicyValid = runDirectionPolicy === directionPolicy && (suppressedDirection == null || approvedForDirection(
+            artifact.byDirection,
+            suppressedDirection
+          ) === 0 && terminalWindows.every(
+            (window) => approvedForDirection(
+              window.byDirection,
+              suppressedDirection
+            ) === 0
+          ));
           const terminalsPass = terminalWindows.length > 0 && terminalWindows.every((window) => {
             const terminalOutcome = nested(window.outcome);
             return window.complete === true && Number(terminalOutcome?.approved ?? 0) > 0 && Number(
@@ -1310,7 +1375,7 @@ async function collectReleaseEvidenceReferences(references) {
             ) > 0;
           });
           return {
-            aiGateAddsValue: Number(outcome?.expectancyDelta ?? Number.NEGATIVE_INFINITY) > 0 && Number(approvedRisk?.totalProfit ?? Number.NEGATIVE_INFINITY) > 0 && Number(approvedRisk?.profitFactor ?? Number.NEGATIVE_INFINITY) > 1 && directionalEvidenceComplete && terminalsPass
+            aiGateAddsValue: Number(outcome?.expectancyDelta ?? Number.NEGATIVE_INFINITY) > 0 && Number(approvedRisk?.totalProfit ?? Number.NEGATIVE_INFINITY) > 0 && Number(approvedRisk?.profitFactor ?? Number.NEGATIVE_INFINITY) > 1 && directionalEvidenceComplete && directionPolicyValid && terminalsPass
           };
         }
         if (reference.kind === "runtime_parity") {

package/dist/scripts/agentRun.js

@@ -40,6 +40,7 @@ var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_constants = require("@tradejs/core/constants");
+var import_aiEndpoints = require("@tradejs/core/aiEndpoints");
 var import_redis = require("@tradejs/infra/redis");
 var import_userSettings = require("@tradejs/infra/userSettings");
 
@@ -415,35 +416,33 @@ var extractAssistantContent = (value) => {
 };
 var requestAgentDiff = async (userName, messages) => {
   const settings = await (0, import_userSettings.getUserSettings)(userName);
-  if (!settings.AI_API_KEY || !settings.AI_API_ENDPOINT) {
+  const aiApiEndpoint = (0, import_aiEndpoints.normalizeAiEndpoint)(settings.AI_API_ENDPOINT);
+  if (!settings.AI_API_KEY || !aiApiEndpoint) {
     throw new Error(`AI settings are incomplete for user ${userName}`);
   }
-  if (!isOpenRouterEndpoint(settings.AI_API_ENDPOINT)) {
+  if (!isOpenRouterEndpoint(aiApiEndpoint)) {
     throw new Error(
-      `Research agent requires OpenRouter endpoint, got: ${settings.AI_API_ENDPOINT}`
+      `Research agent requires OpenRouter endpoint, got: ${aiApiEndpoint}`
     );
   }
-  const response = await fetch(
-    resolveChatCompletionsUrl(settings.AI_API_ENDPOINT),
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${settings.AI_API_KEY}`,
-        "Content-Type": "application/json",
-        "HTTP-Referer": "https://tradejs.dev",
-        "X-Title": "TradeJS Research Agent"
+  const response = await fetch(resolveChatCompletionsUrl(aiApiEndpoint), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${settings.AI_API_KEY}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://tradejs.dev",
+      "X-Title": "TradeJS Research Agent"
+    },
+    body: JSON.stringify({
+      model: RESEARCH_AGENT_MODEL,
+      messages,
+      reasoning: {
+        effort: RESEARCH_AGENT_REASONING_EFFORT,
+        exclude: true
       },
-      body: JSON.stringify({
-        model: RESEARCH_AGENT_MODEL,
-        messages,
-        reasoning: {
-          effort: RESEARCH_AGENT_REASONING_EFFORT,
-          exclude: true
-        },
-        temperature: 0.2
-      })
-    }
-  );
+      temperature: 0.2
+    })
+  });
   if (!response.ok) {
     throw new Error(
       `OpenRouter request failed (${response.status}): ${await response.text()}`

package/dist/scripts/aiPocketSearch.js

@@ -40,6 +40,7 @@ var import_path = __toESM(require("path"));
 var import_progress = __toESM(require("progress"));
 var import_ai = require("@tradejs/infra/ai");
 var import_ai2 = require("@tradejs/node/ai");
+var import_registry = require("@tradejs/node/registry");
 
 // src/lib/aiTrainDataset.ts
 var extractSignalFromAiDatasetRow = (row) => {
@@ -3482,7 +3483,7 @@ var main = async () => {
   const explicitReportFile = String(flags.reportFile || "").trim();
   const generatedAt = Date.now();
   const excludedFeaturePaths = /* @__PURE__ */ new Map();
-  await (0, import_ai2.ensureAiStrategyPluginsLoaded)();
+  await (0, import_registry.ensureStrategyPluginsLoaded)();
   const filePaths = await resolveMergedDatasetFiles({
     outDir,
     strategyName,