@tradejs/node 3.1.2 → 3.1.4

package/dist/runtimeStrategies.mjs

@@ -8,9 +8,7 @@ import "./chunk-Y6FXYEAI.mjs";
 // src/runtimeStrategies.ts
 import { readFile } from "fs/promises";
 import path from "path";
-import { getData, redisKeys } from "@tradejs/infra/redis";
 import { getRuntimeStrategyRelease } from "@tradejs/infra/runtimeStrategyReleases";
-import { loadRuntimeStrategyConfigs } from "@tradejs/infra/runtimeStrategyConfigs";
 import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
 var readPackageManifest = async (projectRoot) => {
   const candidates = [
@@ -55,13 +53,17 @@ var validateReleaseRuntimeCompatibility = async ({
     release.strategyPackage,
     packageManifest
   );
-  if (release.strategyPackageVersion && installedStrategyVersion && release.strategyPackageVersion !== installedStrategyVersion) {
+  if (release.strategyPackageVersion !== installedStrategyVersion) {
     throw new Error(
       `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
     );
   }
-  const installedRuntimeVersion = packageManifest.packages?.["@tradejs/node"];
-  if (release.runtimePackageVersion && installedRuntimeVersion && release.runtimePackageVersion !== installedRuntimeVersion) {
+  const installedRuntimeVersion = await resolveInstalledPackageVersion(
+    projectRoot,
+    "@tradejs/node",
+    packageManifest
+  );
+  if (release.runtimePackageVersion !== installedRuntimeVersion) {
     throw new Error(
       `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
     );
@@ -70,24 +72,20 @@ var validateReleaseRuntimeCompatibility = async ({
 var resolveAccountId = async ({
   userName,
   deployment,
-  connectorName,
-  universe,
-  legacyAccountId
+  universe
 }) => {
-  const requestedAccountId = deployment?.accountId ?? legacyAccountId;
   const account = await resolveTradingAccount({
     userName,
-    accountId: requestedAccountId,
-    provider: deployment?.provider ?? connectorName,
+    accountId: deployment.accountId,
+    provider: deployment.provider,
     universe
   });
-  return account?.id ?? requestedAccountId;
+  return account?.id ?? deployment.accountId;
 };
 var loadVersionedRuntimeStrategies = async ({
   userName,
   projectRoot,
-  deployment,
-  connectorName
+  deployment
 }) => {
   const packageManifest = await readPackageManifest(projectRoot);
   return Promise.all(
@@ -97,9 +95,14 @@ var loadVersionedRuntimeStrategies = async ({
           `Deployment ${deployment.id} strategy ${reference.strategyName} has no releaseVersion`
         );
       }
-      if (reference.config && Object.keys(reference.config).length) {
+      if (Object.keys(reference).some(
+        (key) => !["strategyName", "releaseVersion", "controlState"].includes(key)
+      )) {
+        throw new Error(`Deployment ${deployment.id} has invalid fields`);
+      }
+      if (!reference.controlState) {
         throw new Error(
-          `Deployment ${deployment.id} must not embed config for ${reference.strategyName}`
+          `Deployment ${deployment.id} strategy ${reference.strategyName} has no controlState`
         );
       }
       const release = await getRuntimeStrategyRelease(
@@ -129,13 +132,12 @@ var loadVersionedRuntimeStrategies = async ({
       const accountId = await resolveAccountId({
         userName,
         deployment,
-        connectorName,
         universe
       });
       return {
         strategyName: reference.strategyName,
         releaseVersion: release.releaseVersion,
-        controlState: reference.controlState ?? "active",
+        controlState: reference.controlState,
         interval,
         universe,
         accountId,
@@ -144,90 +146,24 @@ var loadVersionedRuntimeStrategies = async ({
         runtimePackageVersion: release.runtimePackageVersion,
         strategyCreator,
         sourceStrategyConfig: release.config,
-        strategyConfig: release.config,
-        // Symbol result configs are mutable legacy overlays and are not read by v2.
-        strategyResults: {}
+        strategyConfig: release.config
       };
     })
   );
 };
-var loadLegacyRuntimeStrategies = async ({
-  userName,
-  projectRoot,
-  deployment,
-  connectorName
-}) => {
-  const deploymentStrategies = new Map(
-    (deployment?.strategies ?? []).map((strategy) => [
-      strategy.strategyName,
-      strategy
-    ])
-  );
-  const candidates = await Promise.all(
-    (await loadRuntimeStrategyConfigs(userName)).map(async (record) => {
-      const binding = deploymentStrategies.get(record.strategyName);
-      if (binding?.enabled === false || record.strategyConfig.ENABLE === false) {
-        return null;
-      }
-      const universe = record.strategyConfig.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
-      const interval = String(
-        record.strategyConfig.INTERVAL ?? "15"
-      );
-      const accountId = await resolveAccountId({
-        userName,
-        deployment,
-        connectorName,
-        universe,
-        legacyAccountId: typeof record.strategyConfig.ACCOUNT_ID === "string" ? record.strategyConfig.ACCOUNT_ID : void 0
-      });
-      const [strategyCreator, strategyResults] = await Promise.all([
-        getStrategyCreator(record.strategyName, projectRoot),
-        getData(redisKeys.strategyResults(userName, record.strategyName), {})
-      ]);
-      if (!strategyCreator) return null;
-      return {
-        strategyName: record.strategyName,
-        configId: record.configId,
-        controlState: "active",
-        interval,
-        universe,
-        accountId,
-        strategyCreator,
-        sourceStrategyConfig: record.strategyConfig,
-        strategyConfig: record.strategyConfig,
-        strategyResults: strategyResults ?? {}
-      };
-    })
-  );
-  return candidates.filter(Boolean);
-};
 var loadResolvedRuntimeStrategies = async ({
   userName,
   projectRoot,
   deployment,
-  connectorName = "bybit",
   universe,
   accountId,
   interval
 }) => {
-  const hasVersionedReferences = Boolean(
-    deployment?.strategies.some((strategy) => strategy.releaseVersion != null)
-  );
-  if (hasVersionedReferences && deployment?.strategies.some((strategy) => strategy.releaseVersion == null)) {
-    throw new Error(
-      `Deployment ${deployment.id} mixes legacy configs and versioned releases`
-    );
-  }
-  const strategies = hasVersionedReferences ? await loadVersionedRuntimeStrategies({
-    userName,
-    projectRoot,
-    deployment,
-    connectorName
-  }) : await loadLegacyRuntimeStrategies({
+  if (!deployment) throw new Error("Runtime deployment is required");
+  const strategies = await loadVersionedRuntimeStrategies({
     userName,
     projectRoot,
-    deployment,
-    connectorName
+    deployment
   });
   const filtered = strategies.filter(
     (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)

package/dist/strategies.d.mts

@@ -24,7 +24,7 @@ interface ResolveStrategyConfigParams<TConfig extends StrategyConfig> {
     runtimeConfigId?: string;
     runtimeConfigSnapshot?: RuntimeStrategyConfigSnapshot;
 }
-declare const resolveStrategyConfig: <TConfig extends StrategyConfig>({ strategyName, userName, symbol, baseConfig, defaults, runtimeConfigId, runtimeConfigSnapshot, }: ResolveStrategyConfigParams<TConfig>) => Promise<{
+declare const resolveStrategyConfig: <TConfig extends StrategyConfig>({ strategyName, baseConfig, defaults, runtimeConfigSnapshot, }: ResolveStrategyConfigParams<TConfig>) => Promise<{
     config: TConfig;
     isConfigFromBacktest: boolean;
 }>;

package/dist/strategies.d.ts

@@ -24,7 +24,7 @@ interface ResolveStrategyConfigParams<TConfig extends StrategyConfig> {
     runtimeConfigId?: string;
     runtimeConfigSnapshot?: RuntimeStrategyConfigSnapshot;
 }
-declare const resolveStrategyConfig: <TConfig extends StrategyConfig>({ strategyName, userName, symbol, baseConfig, defaults, runtimeConfigId, runtimeConfigSnapshot, }: ResolveStrategyConfigParams<TConfig>) => Promise<{
+declare const resolveStrategyConfig: <TConfig extends StrategyConfig>({ strategyName, baseConfig, defaults, runtimeConfigSnapshot, }: ResolveStrategyConfigParams<TConfig>) => Promise<{
     config: TConfig;
     isConfigFromBacktest: boolean;
 }>;

package/dist/strategies.js

@@ -4592,14 +4592,10 @@ var updatePositionProtection = async ({
 
 // src/strategyHelpers/config.ts
 var import_lodash = __toESM(require("lodash"));
-var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
 var resolveStrategyConfig = async ({
   strategyName,
-  userName,
-  symbol,
   baseConfig,
   defaults,
-  runtimeConfigId,
   runtimeConfigSnapshot
 }) => {
   const mergeIfNotEmpty = (target, patch) => patch && !import_lodash.default.isEmpty(patch) ? {
@@ -4612,22 +4608,13 @@ var resolveStrategyConfig = async ({
   };
   let isConfigFromBacktest = false;
   if (config.ENV !== "BACKTEST") {
-    const userConfig = runtimeConfigSnapshot ? runtimeConfigSnapshot.userConfig : await (0, import_runtimeStrategyConfigs.getRuntimeStrategyConfig)(
-      userName,
-      strategyName,
-      runtimeConfigId
-    ) ?? {};
-    config = mergeIfNotEmpty(config, userConfig);
-    if (!runtimeConfigId || runtimeConfigId === "config") {
-      const symbolResultConfig = runtimeConfigSnapshot ? runtimeConfigSnapshot.symbolResultConfig : await (0, import_runtimeStrategyConfigs.getRuntimeStrategyResultConfig)(userName, strategyName, symbol);
-      if (symbolResultConfig && !import_lodash.default.isEmpty(symbolResultConfig)) {
-        config = mergeIfNotEmpty(
-          config,
-          symbolResultConfig
-        );
-        isConfigFromBacktest = true;
-      }
+    if (!runtimeConfigSnapshot) {
+      throw new Error(
+        `Runtime strategy release snapshot is required for ${strategyName}`
+      );
     }
+    const userConfig = runtimeConfigSnapshot.userConfig;
+    config = mergeIfNotEmpty(config, userConfig);
   }
   return { config, isConfigFromBacktest };
 };
@@ -5462,7 +5449,6 @@ var createStrategyRuntime = ({
   };
   const creator = async ({
     userName,
-    connectorName,
     config: baseConfig,
     symbol,
     universe: requestedUniverse,

package/dist/strategies.mjs

@@ -1,10 +1,3 @@
-import {
-  closeOppositePositionsBeforeOpen,
-  createCloseAllOnGlobalProfitBeforeSignalsHook,
-  createCloseOppositeBeforePlaceOrderHook,
-  createMoveStopToBreakEvenAfterCoreDecisionHook,
-  createMoveStopToBreakEvenOnBarHook
-} from "./chunk-LAJ7NA3Q.mjs";
 import {
   BINANCE_BREADTH_UNIVERSE_KEYS,
   buildBinanceBreadthUniverseSnapshot,
@@ -29,7 +22,7 @@ import {
   resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig,
   validateEntryProtectionAtArrival
-} from "./chunk-W26Y6IRP.mjs";
+} from "./chunk-MCDICN3I.mjs";
 import {
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
@@ -64,6 +57,376 @@ import {
 } from "./chunk-XN7BC7XK.mjs";
 import "./chunk-WS5DYEVZ.mjs";
 import "./chunk-Y6FXYEAI.mjs";
+
+// src/strategies.ts
+export * from "@tradejs/core/strategies";
+
+// src/strategyHooks/closeOppositePositionsBeforeOpen.ts
+import _ from "lodash";
+import { logger } from "@tradejs/infra/logger";
+var closeOppositePositionsBeforeOpen = async ({
+  connector,
+  entryContext
+}) => {
+  const {
+    symbol: currentSymbol,
+    direction: currentDirection,
+    timestamp,
+    prices,
+    strategy: strategyName
+  } = entryContext;
+  const price = prices.currentPrice;
+  try {
+    logger.log(
+      "info",
+      "[%s] checking open positions before open: %s %s",
+      strategyName,
+      currentSymbol,
+      currentDirection
+    );
+    const positions = await connector.getPositions();
+    const openPositions = (positions || []).filter(
+      (item) => item && Number(item.qty) > 0
+    );
+    logger.log(
+      "info",
+      "[%s] open positions found: %s",
+      strategyName,
+      openPositions.length
+    );
+    const oppositePositions = openPositions.filter(
+      (item) => item.symbol !== currentSymbol && item.direction !== currentDirection
+    );
+    if (_.isEmpty(oppositePositions)) {
+      logger.log(
+        "info",
+        "[%s] no opposite positions to close before open: %s",
+        strategyName,
+        currentSymbol
+      );
+      return;
+    }
+    for (const position of oppositePositions) {
+      logger.log(
+        "info",
+        "[%s] closing opposite position: %s %s qty=%s",
+        strategyName,
+        position.symbol,
+        position.direction,
+        position.qty
+      );
+      try {
+        await connector.closePosition({
+          symbol: position.symbol,
+          price,
+          timestamp,
+          direction: position.direction
+        });
+        logger.log(
+          "info",
+          "[%s] opposite position closed: %s",
+          strategyName,
+          position.symbol
+        );
+      } catch (err) {
+        logger.log(
+          "error",
+          "[%s] failed to close opposite position: %s %s",
+          strategyName,
+          position.symbol,
+          err
+        );
+      }
+    }
+  } catch (err) {
+    logger.log(
+      "error",
+      "[%s] failed to load open positions before open: %s %s",
+      strategyName,
+      currentSymbol,
+      err
+    );
+  }
+};
+var createCloseOppositeBeforePlaceOrderHook = ({
+  isEnabled
+}) => {
+  return async ({ ctx, entry }) => {
+    if (ctx.env === "BACKTEST") {
+      return;
+    }
+    if (!isEnabled(ctx.strategyConfig)) {
+      return;
+    }
+    await closeOppositePositionsBeforeOpen({
+      connector: ctx.connector,
+      entryContext: entry.context
+    });
+  };
+};
+
+// src/strategyHooks/shared.ts
+var DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
+var DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER = 0;
+var DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER = 4;
+var GLOBAL_UNREALIZED_PNL_CLOSE_ALL_CODE = "GLOBAL_UNREALIZED_PNL_TARGET_REACHED_CLOSE_ALL";
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var isOpenPosition = (position) => Boolean(
+  position && isFiniteNumber(position.price) && isFiniteNumber(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var isOpenPositionPnlSnapshot = (position) => Boolean(
+  isOpenPosition(position) && isFiniteNumber(position?.currentPrice) && isFiniteNumber(position?.unrealizedPnl)
+);
+var getStrategyMaxLossValue = (strategyConfig) => {
+  const maxLossValue = Number(strategyConfig?.MAX_LOSS_VALUE ?? Number.NaN);
+  return Number.isFinite(maxLossValue) && maxLossValue > 0 ? maxLossValue : null;
+};
+var getPositionStopLossPrice = (position) => {
+  if (!position || typeof position !== "object") {
+    return null;
+  }
+  const slPrice = Number(
+    position.slPrice ?? Number.NaN
+  );
+  if (Number.isFinite(slPrice)) {
+    return slPrice;
+  }
+  const signalStopLossPrice = Number(
+    position.signal?.prices?.stopLossPrice ?? Number.NaN
+  );
+  return Number.isFinite(signalStopLossPrice) ? signalStopLossPrice : null;
+};
+var getPositionTakeProfitPrice = (position) => {
+  if (!position || typeof position !== "object") {
+    return null;
+  }
+  const directTakeProfitPrice = Number(
+    position.tpPrice ?? position.takeProfitPrice ?? Number.NaN
+  );
+  if (Number.isFinite(directTakeProfitPrice)) {
+    return directTakeProfitPrice;
+  }
+  const signalTakeProfitPrice = Number(
+    position.signal?.prices?.takeProfitPrice ?? Number.NaN
+  );
+  return Number.isFinite(signalTakeProfitPrice) ? signalTakeProfitPrice : null;
+};
+var getBreakEvenStopPrice = ({
+  direction,
+  entryPrice,
+  takeProfitPrice,
+  stopProfitMultiplier
+}) => {
+  if (!Number.isFinite(entryPrice)) {
+    return null;
+  }
+  const normalizedStopProfitMultiplier = Number.isFinite(stopProfitMultiplier) ? Math.min(Math.max(stopProfitMultiplier, 0), 1) : DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER;
+  if (takeProfitPrice == null || !Number.isFinite(takeProfitPrice) || direction === "LONG" && takeProfitPrice <= entryPrice || direction === "SHORT" && takeProfitPrice >= entryPrice) {
+    return entryPrice;
+  }
+  const distanceToTakeProfit = takeProfitPrice - entryPrice;
+  return entryPrice + distanceToTakeProfit * normalizedStopProfitMultiplier;
+};
+var getFavorableMovePct = ({
+  direction,
+  entryPrice,
+  currentPrice
+}) => {
+  if (!Number.isFinite(entryPrice) || !Number.isFinite(currentPrice) || entryPrice <= 0) {
+    return null;
+  }
+  return direction === "LONG" ? (currentPrice - entryPrice) / entryPrice * 100 : (entryPrice - currentPrice) / entryPrice * 100;
+};
+var getPositionRiskPct = ({
+  direction,
+  entryPrice,
+  stopLossPrice
+}) => {
+  if (stopLossPrice == null || !Number.isFinite(entryPrice) || !Number.isFinite(stopLossPrice) || entryPrice <= 0) {
+    return null;
+  }
+  return direction === "LONG" ? (entryPrice - stopLossPrice) / entryPrice * 100 : (stopLossPrice - entryPrice) / entryPrice * 100;
+};
+var isBreakEvenStopAlreadyApplied = ({
+  direction,
+  entryPrice,
+  stopLossPrice
+}) => {
+  if (stopLossPrice == null || !Number.isFinite(entryPrice) || !Number.isFinite(stopLossPrice)) {
+    return false;
+  }
+  return direction === "LONG" ? stopLossPrice >= entryPrice : stopLossPrice <= entryPrice;
+};
+var getConfiguredDirectionRiskPct = ({
+  strategyConfig,
+  direction
+}) => {
+  if (!strategyConfig || typeof strategyConfig !== "object") {
+    return null;
+  }
+  const directSideConfig = strategyConfig[direction];
+  const directSideRiskPct = Number(directSideConfig?.SL ?? Number.NaN);
+  if (Number.isFinite(directSideRiskPct)) {
+    return directSideRiskPct;
+  }
+  for (const candidate of Object.values(strategyConfig)) {
+    if (!candidate || typeof candidate !== "object") {
+      continue;
+    }
+    const candidateDirection = candidate.direction;
+    const candidateRiskPct = Number(
+      candidate.SL ?? Number.NaN
+    );
+    if (candidateDirection === direction && Number.isFinite(candidateRiskPct)) {
+      return candidateRiskPct;
+    }
+  }
+  return null;
+};
+var toStrategyCodePrefix = (strategyName) => strategyName === "TrendLine" ? "TRENDLINE" : strategyName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase();
+
+// src/strategyHooks/moveStopToBreakEvenAfterCoreDecision.ts
+var createMoveStopToBreakEvenOnBarHook = ({
+  isEnabled = () => true,
+  triggerRiskMultiplier = DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER,
+  stopProfitMultiplier = DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER
+} = {}) => {
+  return async ({ ctx, market }) => {
+    if (!isEnabled(ctx.strategyConfig)) {
+      return;
+    }
+    const currentPosition = await ctx.connector.getPosition(ctx.symbol);
+    if (!isOpenPosition(currentPosition)) {
+      return;
+    }
+    const currentPrice = Number(market.candle.close ?? Number.NaN);
+    if (!Number.isFinite(currentPrice)) {
+      return;
+    }
+    const currentStopLossPrice = getPositionStopLossPrice(currentPosition);
+    if (isBreakEvenStopAlreadyApplied({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      stopLossPrice: currentStopLossPrice
+    })) {
+      return;
+    }
+    const favorableMovePct = getFavorableMovePct({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      currentPrice
+    });
+    const currentPositionRiskPct = getPositionRiskPct({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      stopLossPrice: currentStopLossPrice
+    });
+    const configuredRiskPct = getConfiguredDirectionRiskPct({
+      strategyConfig: ctx.strategyConfig,
+      direction: currentPosition.direction
+    });
+    const triggerRiskPct = currentPositionRiskPct ?? configuredRiskPct;
+    if (favorableMovePct == null || triggerRiskPct == null || favorableMovePct < triggerRiskPct * triggerRiskMultiplier) {
+      return;
+    }
+    const stopLossPrice = getBreakEvenStopPrice({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      takeProfitPrice: getPositionTakeProfitPrice(currentPosition),
+      stopProfitMultiplier
+    });
+    if (stopLossPrice == null) {
+      return;
+    }
+    return {
+      kind: "protect",
+      code: `${toStrategyCodePrefix(ctx.strategyName)}_MOVE_STOP_TO_BREAK_EVEN`,
+      protectPlan: {
+        direction: currentPosition.direction,
+        stopLossPrice
+      }
+    };
+  };
+};
+var createMoveStopToBreakEvenAfterCoreDecisionHook = createMoveStopToBreakEvenOnBarHook;
+
+// src/signalsHooks/closeAllPositionsOnGlobalProfitBeforeSignals.ts
+import { logger as logger2 } from "@tradejs/infra/logger";
+var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
+  getStrategyDefaultConfig = () => void 0,
+  profitRiskMultiplier = DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER
+} = {}) => {
+  return async ({ connector, runtimeStrategies }) => {
+    if (typeof connector.getOpenPositionPnl !== "function") {
+      return;
+    }
+    const openPositions = (await connector.getOpenPositionPnl()).filter(
+      isOpenPositionPnlSnapshot
+    );
+    if (!openPositions.length) {
+      return;
+    }
+    const totalUnrealizedPnl = openPositions.reduce(
+      (sum, position) => sum + position.unrealizedPnl,
+      0
+    );
+    if (!Number.isFinite(totalUnrealizedPnl) || totalUnrealizedPnl <= 0) {
+      return;
+    }
+    const maxLossValues = runtimeStrategies.flatMap(
+      ({ strategyName, strategyConfig }) => {
+        const maxLossValue = getStrategyMaxLossValue({
+          ...getStrategyDefaultConfig(strategyName) ?? {},
+          ...strategyConfig ?? {}
+        });
+        return maxLossValue == null ? [] : [maxLossValue];
+      }
+    );
+    if (!maxLossValues.length) {
+      return;
+    }
+    const averageMaxLossValue = maxLossValues.reduce((sum, value) => sum + value, 0) / maxLossValues.length;
+    const unrealizedPnlThreshold = averageMaxLossValue * profitRiskMultiplier;
+    if (!Number.isFinite(unrealizedPnlThreshold) || unrealizedPnlThreshold <= 0 || totalUnrealizedPnl < unrealizedPnlThreshold) {
+      return;
+    }
+    logger2.info(
+      "closing all positions before signals by global unrealized pnl threshold: totalPnl=%s threshold=%s positions=%s",
+      totalUnrealizedPnl,
+      unrealizedPnlThreshold,
+      openPositions.length
+    );
+    const closeTimestamp = Date.now();
+    const closeResults = await Promise.allSettled(
+      openPositions.map(
+        (position) => connector.closePosition({
+          symbol: position.symbol,
+          direction: position.direction,
+          price: position.currentPrice,
+          timestamp: closeTimestamp
+        })
+      )
+    );
+    const failedClosures = closeResults.flatMap((result, index) => {
+      if (result.status === "fulfilled" && result.value === true) {
+        return [];
+      }
+      return [
+        `${openPositions[index]?.symbol}:${openPositions[index]?.direction ?? "UNKNOWN"}`
+      ];
+    });
+    if (failedClosures.length) {
+      logger2.warn(
+        "close-all before signals hook could not confirm closures for %s",
+        failedClosures.join(", ")
+      );
+    }
+    return {
+      abort: true,
+      reason: GLOBAL_UNREALIZED_PNL_CLOSE_ALL_CODE
+    };
+  };
+};
 export {
   BINANCE_BREADTH_UNIVERSE_KEYS,
   DEFAULT_AI_MODEL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "description": "Node-only runtime for the TradeJS TypeScript framework: strategies, backtests, Pine strategy loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -85,9 +85,9 @@
   "dependencies": {
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/core": "^3.1.2",
-    "@tradejs/infra": "^3.1.2",
-    "@tradejs/types": "^3.1.2",
+    "@tradejs/core": "^3.1.4",
+    "@tradejs/infra": "^3.1.4",
+    "@tradejs/types": "^3.1.4",
     "chalk": "4.1.2",
     "ioredis": "5.11.1",
     "lodash": "^4.18.1",