@tradejs/node 1.0.5 → 1.0.8

package/dist/strategies.mjs

@@ -1,21 +1,30 @@
 import {
-  buildMlPayload
-} from "./chunk-RBE4PZER.mjs";
+  buildMlPayload,
+  enrichSignalWithDerivativesContext
+} from "./chunk-JRRG3YQG.mjs";
 import {
   require_lodash
-} from "./chunk-GKDBAF3A.mjs";
-import {
-  createLoadPineScript
-} from "./chunk-7ICOZAKA.mjs";
-import "./chunk-5YNMSWL3.mjs";
+} from "./chunk-KZDHZ56N.mjs";
 import {
+  DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
   askAI,
   buildAiHumanPrompt,
   buildAiPayload,
+  buildAiPrompts,
   buildAiSystemPrompt,
+  ensureAiStrategyPluginsLoaded,
+  getDeterministicAiGateContext,
+  getOpenRouterModelKwargs,
+  resetAiRuntimeCache,
+  runAiPrompt,
+  runAiPromptLocal,
   trimSeriesDeep
-} from "./chunk-LMAKIC3C.mjs";
+} from "./chunk-2JKX3DM7.mjs";
+import {
+  createPineScriptLoader
+} from "./chunk-H6LIYHU4.mjs";
+import "./chunk-5YNMSWL3.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -28,102 +37,15 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-ZY6ULOWK.mjs";
+} from "./chunk-WGOYR6AB.mjs";
 import {
-  getTradejsProjectCwd
-} from "./chunk-P2ZUWONT.mjs";
+  getTradejsProjectCwd,
+  loadTradejsConfig
+} from "./chunk-JU77QVJ3.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
 
-// src/closeOppositePositionsBeforeOpen.ts
-var import_lodash = __toESM(require_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 (import_lodash.default.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
-    );
-  }
-};
-
 // src/strategies.ts
 export * from "@tradejs/core/strategies";
 
@@ -140,12 +62,125 @@ import { logger as logger3 } from "@tradejs/infra/logger";
 
 // src/strategyHelpers/runtime.ts
 import { logger as logger2 } from "@tradejs/infra/logger";
+import { redisKeys as redisKeys2, setData as setData2 } from "@tradejs/infra/redis";
 import {
   buildMlFeatures,
   buildMlTrainingRow,
   fetchMlThreshold,
   trimMlTrainingRowWindows
 } from "@tradejs/infra/ml";
+
+// src/runtimeJournal.ts
+import { randomUUID } from "crypto";
+import { TTL_1M } from "@tradejs/core/constants";
+import { logger } from "@tradejs/infra/logger";
+import { delKey, getData, redisKeys, setData } from "@tradejs/infra/redis";
+var now = () => Date.now();
+var toOrderId = () => `tjs-${randomUUID().replace(/-/g, "").slice(0, 24).toLowerCase()}`;
+var calculateClosedPnl = ({
+  direction,
+  entryPrice,
+  exitPrice,
+  qty
+}) => {
+  const pnl = direction === "LONG" ? (exitPrice - entryPrice) * qty : (entryPrice - exitPrice) * qty;
+  return Number.isFinite(pnl) ? pnl : null;
+};
+var createRuntimeOrderId = () => toOrderId();
+var recordRuntimeTradeOpen = async (params) => {
+  const { userName } = params;
+  if (!userName) {
+    return null;
+  }
+  const record = {
+    ...params,
+    status: "active",
+    currentPrice: params.entryPrice,
+    currentPnl: 0,
+    closedPnl: null,
+    exitPrice: null,
+    exitTimestamp: null,
+    lastSyncedAt: now()
+  };
+  try {
+    await Promise.all([
+      setData(redisKeys.runtimeTrade(userName, record.orderId), record, {
+        expire: 0
+      }),
+      setData(
+        redisKeys.runtimeActiveTrade(userName, record.symbol),
+        { orderId: record.orderId },
+        { expire: 0 }
+      )
+    ]);
+  } catch (error) {
+    logger.error(
+      "runtime trade open journal failed: %s %s",
+      record.symbol,
+      error?.message || String(error)
+    );
+  }
+  return record;
+};
+var markRuntimeTradeClosed = async (params) => {
+  const { userName, symbol, strategy, exitPrice, exitTimestamp, closedPnl } = params;
+  if (!userName) {
+    return null;
+  }
+  const activeRef = await getData(
+    redisKeys.runtimeActiveTrade(userName, symbol),
+    null
+  );
+  const orderId = String(activeRef?.orderId || "").trim();
+  if (!orderId) {
+    return null;
+  }
+  const existing = await getData(
+    redisKeys.runtimeTrade(userName, orderId),
+    null
+  );
+  if (!existing) {
+    await delKey(redisKeys.runtimeActiveTrade(userName, symbol));
+    return null;
+  }
+  if (strategy && existing.strategy !== strategy) {
+    return null;
+  }
+  const resolvedExitPrice = typeof exitPrice === "number" && Number.isFinite(exitPrice) ? exitPrice : existing.currentPrice ?? existing.entryPrice;
+  const resolvedClosedPnl = typeof closedPnl === "number" && Number.isFinite(closedPnl) ? closedPnl : typeof resolvedExitPrice === "number" && Number.isFinite(resolvedExitPrice) ? calculateClosedPnl({
+    direction: existing.direction,
+    entryPrice: existing.entryPrice,
+    exitPrice: resolvedExitPrice,
+    qty: existing.qty
+  }) : existing.closedPnl ?? existing.currentPnl ?? null;
+  const next = {
+    ...existing,
+    status: "closed",
+    currentPrice: resolvedExitPrice,
+    currentPnl: resolvedClosedPnl,
+    closedPnl: resolvedClosedPnl,
+    exitPrice: resolvedExitPrice,
+    exitTimestamp: typeof exitTimestamp === "number" && Number.isFinite(exitTimestamp) ? exitTimestamp : now(),
+    lastSyncedAt: now()
+  };
+  try {
+    await Promise.all([
+      setData(redisKeys.runtimeTrade(userName, orderId), next, {
+        expire: TTL_1M
+      }),
+      delKey(redisKeys.runtimeActiveTrade(userName, symbol))
+    ]);
+  } catch (error) {
+    logger.error(
+      "runtime trade close journal failed: %s %s",
+      symbol,
+      error?.message || String(error)
+    );
+  }
+  return next;
+};
+
+// src/strategyHelpers/runtime.ts
 var formatAiError = (err) => {
   const error = err;
   const safeJson = (value) => {
@@ -164,6 +199,60 @@ var formatAiError = (err) => {
   };
   return safeJson(details);
 };
+var resolveAiQuality = (analysis, direction) => {
+  if (typeof analysis?.quality !== "number") {
+    return void 0;
+  }
+  const normalizedQuality = Math.round(analysis.quality);
+  const aiApprovedCurrentTrade = analysis.direction === direction;
+  return aiApprovedCurrentTrade ? normalizedQuality : 0;
+};
+var resolveAiDecision = (analysis, direction, minQuality = 4) => {
+  const quality = resolveAiQuality(analysis, direction);
+  return quality != null && quality >= minQuality ? "approved" : "rejected";
+};
+var withGateComparison = ({
+  llmAnalysis,
+  gateAnalysis,
+  direction,
+  minQuality
+}) => {
+  const gateDecision = resolveAiDecision(gateAnalysis, direction, minQuality);
+  const llmDecision = resolveAiDecision(llmAnalysis, direction, minQuality);
+  return {
+    ...llmAnalysis,
+    gateAnalysis,
+    gateDecision,
+    llmDecision,
+    gateContradictsLlm: gateDecision !== llmDecision
+  };
+};
+var findReplayAiAnalysis = ({
+  signal,
+  direction,
+  ai
+}) => {
+  const snapshots = ai?.replayAnalyses;
+  if (!Array.isArray(snapshots) || !snapshots.length) {
+    return void 0;
+  }
+  let best = null;
+  for (const snapshot of snapshots) {
+    if (snapshot.symbol !== signal.symbol || snapshot.direction !== direction || snapshot.strategy && snapshot.strategy !== signal.strategy) {
+      continue;
+    }
+    const toleranceMs = Math.max(0, Number(snapshot.toleranceMs ?? 0));
+    const diff = Math.abs(snapshot.timestamp - signal.timestamp);
+    if (diff > toleranceMs || best && diff >= best.diff) {
+      continue;
+    }
+    best = {
+      diff,
+      analysis: snapshot.analysis
+    };
+  }
+  return best?.analysis;
+};
 var enrichSignalWithMl = async ({
   signal,
   env,
@@ -198,21 +287,53 @@ var enrichSignalWithMl = async ({
 var enrichSignalWithAi = async ({
   signal,
   symbol,
+  userName,
   direction,
   env,
   ai
 }) => {
-  if (env === "BACKTEST" || ai?.enabled === false) {
+  if (ai?.enabled === false) {
     return void 0;
   }
-  try {
-    const { askAI: askAI2 } = await import("./ai-G7ATN4YL.mjs");
-    const analysis = await askAI2(signal);
-    if (typeof analysis?.quality === "number") {
-      const normalizedQuality = Math.round(analysis.quality);
-      const aiApprovedCurrentTrade = analysis?.direction === direction;
-      return aiApprovedCurrentTrade ? normalizedQuality : 0;
+  if (env === "PARITY") {
+    const replayAnalysis = findReplayAiAnalysis({ signal, direction, ai });
+    if (replayAnalysis) {
+      signal.aiAnalysis = replayAnalysis;
+      return resolveAiQuality(replayAnalysis, direction);
+    }
+  }
+  if (env === "BACKTEST") {
+    return void 0;
+  }
+  if (ai?.mode === "gate") {
+    const minQuality = ai.minQuality ?? 4;
+    const { askAI: askAI2, runAiPromptLocal: runAiPromptLocal2 } = await import("./ai.mjs");
+    const gateAnalysis = await runAiPromptLocal2(signal);
+    const gateQuality = resolveAiQuality(gateAnalysis, direction);
+    try {
+      const llmAnalysis = await askAI2(signal, { userName });
+      const comparedAnalysis = withGateComparison({
+        llmAnalysis,
+        gateAnalysis,
+        direction,
+        minQuality
+      });
+      signal.aiAnalysis = comparedAnalysis;
+      await setData2(
+        redisKeys2.analysis(signal.symbol, signal.signalId),
+        comparedAnalysis
+      );
+    } catch (err) {
+      logger2.error("AI analysis error: %s %s", symbol, formatAiError(err));
+      signal.aiAnalysis = gateAnalysis;
     }
+    return gateQuality;
+  }
+  try {
+    const { askAI: askAI2 } = await import("./ai.mjs");
+    const analysis = await askAI2(signal, { userName });
+    signal.aiAnalysis = analysis;
+    return resolveAiQuality(analysis, direction);
   } catch (err) {
     logger2.error("AI analysis error: %s %s", symbol, formatAiError(err));
   }
@@ -220,17 +341,50 @@ var enrichSignalWithAi = async ({
 };
 var enrichSignalWithMlAi = async ({
   signal,
+  userName,
   symbol,
   direction,
   env,
   ml,
   ai
 }) => {
+  await enrichSignalWithDerivativesContext({ signal, env });
   await enrichSignalWithMl({ signal, env, ml });
-  return enrichSignalWithAi({ signal, symbol, direction, env, ai });
+  return enrichSignalWithAi({ signal, userName, symbol, direction, env, ai });
+};
+var applyProtectiveOrders = async ({
+  connector,
+  symbol,
+  direction,
+  qty,
+  takeProfits,
+  stopLossPrice
+}) => {
+  if (Array.isArray(takeProfits) && takeProfits.length > 0) {
+    const tpOk = await connector.setTakeProfits({
+      symbol,
+      direction,
+      qty,
+      takeProfits
+    });
+    if (!tpOk) {
+      throw new Error("SET_TAKE_PROFITS_FAILED");
+    }
+  }
+  if (typeof stopLossPrice === "number" && Number.isFinite(stopLossPrice)) {
+    const slOk = await connector.setStopLoss({
+      symbol,
+      direction,
+      stopLossPrice
+    });
+    if (!slOk) {
+      throw new Error("SET_STOP_LOSS_FAILED");
+    }
+  }
 };
 var executeEntryOrder = async ({
   connector,
+  userName,
   symbol,
   direction,
   qty,
@@ -239,35 +393,87 @@ var executeEntryOrder = async ({
   takeProfits,
   stopLossPrice,
   signal,
-  beforePlaceOrder
+  beforePlaceOrder,
+  recordRuntimeTrade = true
 }) => {
   await beforePlaceOrder?.();
-  const orderPlaced = await connector.placeOrder(
-    {
-      symbol,
-      qty,
-      price: currentPrice,
-      isLimit: false,
-      timestamp,
-      direction,
-      signal
-    },
-    takeProfits,
-    stopLossPrice
-  );
+  const orderId = signal.orderId || createRuntimeOrderId();
+  signal.orderId = orderId;
+  const orderPlaced = await connector.placeOrder({
+    symbol,
+    qty,
+    price: currentPrice,
+    isLimit: false,
+    timestamp,
+    direction,
+    orderId,
+    signal
+  });
+  if (orderPlaced) {
+    try {
+      await applyProtectiveOrders({
+        connector,
+        symbol,
+        direction,
+        qty,
+        takeProfits,
+        stopLossPrice
+      });
+    } catch (error) {
+      await connector.closePosition({
+        symbol,
+        price: currentPrice,
+        timestamp,
+        direction
+      });
+      throw error;
+    }
+  }
   signal.orderStatus = orderPlaced ? "completed" : "failed";
   signal.orderSkipReason = void 0;
   const currentPosition = await connector.getPosition(symbol);
+  const entryPrice = currentPosition?.price && Number.isFinite(currentPosition.price) ? currentPosition.price : currentPrice;
+  signal.prices.currentPrice = entryPrice;
+  if (orderPlaced && recordRuntimeTrade) {
+    await recordRuntimeTradeOpen({
+      userName,
+      orderId,
+      signalId: signal.signalId,
+      strategy: signal.strategy,
+      symbol,
+      direction,
+      qty,
+      entryPrice,
+      entryTimestamp: timestamp,
+      ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
+    });
+  }
   if (currentPosition?.price) {
-    signal.prices.currentPrice = currentPosition.price;
     return currentPosition.price;
   }
-  return currentPrice;
+  return entryPrice;
+};
+var updatePositionProtection = async ({
+  connector,
+  symbol,
+  direction,
+  qty,
+  takeProfits,
+  stopLossPrice
+}) => {
+  await applyProtectiveOrders({
+    connector,
+    symbol,
+    direction,
+    qty,
+    takeProfits: takeProfits ?? [],
+    stopLossPrice: stopLossPrice ?? null
+  });
 };
 
 // src/strategyHelpers/config.ts
-var import_lodash2 = __toESM(require_lodash());
-import { getData, redisKeys } from "@tradejs/infra/redis";
+var import_lodash = __toESM(require_lodash());
+import { getData as getData2, redisKeys as redisKeys3 } from "@tradejs/infra/redis";
 var resolveStrategyConfig = async ({
   strategyName,
   userName,
@@ -275,7 +481,7 @@ var resolveStrategyConfig = async ({
   baseConfig,
   defaults
 }) => {
-  const mergeIfNotEmpty = (target, patch) => patch && !import_lodash2.default.isEmpty(patch) ? {
+  const mergeIfNotEmpty = (target, patch) => patch && !import_lodash.default.isEmpty(patch) ? {
     ...target,
     ...patch
   } : target;
@@ -285,17 +491,17 @@ var resolveStrategyConfig = async ({
   };
   let isConfigFromBacktest = false;
   if (config.ENV !== "BACKTEST") {
-    const userConfig = await getData(
-      redisKeys.strategyConfig(userName, strategyName),
+    const userConfig = await getData2(
+      redisKeys3.strategyConfig(userName, strategyName),
       {}
     );
     config = mergeIfNotEmpty(config, userConfig);
-    const results = await getData(
-      redisKeys.strategyResults(userName, strategyName),
+    const results = await getData2(
+      redisKeys3.strategyResults(userName, strategyName),
       {}
     );
     const backtestResult = results?.[symbol];
-    if (backtestResult && !import_lodash2.default.isEmpty(backtestResult.config)) {
+    if (backtestResult && !import_lodash.default.isEmpty(backtestResult.config)) {
       config = mergeIfNotEmpty(
         config,
         backtestResult.config
@@ -332,27 +538,103 @@ var resolveEntryRuntimePolicy = ({
     ai
   };
 };
+var formatGateNumber = (value) => {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  const normalized = Number(value.toFixed(6));
+  return Number.isInteger(normalized) ? String(normalized) : String(normalized);
+};
+var isMlRuntimeGateEnabled = (params) => {
+  const { env, ml } = params;
+  return env !== "BACKTEST" && ml?.config != null && ml.config.enabled !== false;
+};
+var isMlResultUnavailable = (params) => {
+  const { env, ml } = params;
+  return isMlRuntimeGateEnabled({ env, ml }) && ml?.result == null;
+};
 var shouldExecuteEntryDecision = ({
   makeOrdersEnabled,
   env,
   signal,
+  ml,
+  aiEnabled,
   quality,
   minAiQuality
-}) => makeOrdersEnabled && (!signal || env === "BACKTEST" || quality == null || quality >= minAiQuality);
+}) => {
+  if (!makeOrdersEnabled) {
+    return false;
+  }
+  if (!signal || env === "BACKTEST") {
+    return true;
+  }
+  if (isMlResultUnavailable({ env, ml })) {
+    return false;
+  }
+  if (isMlRuntimeGateEnabled({ env, ml }) && ml?.result?.passed === false) {
+    return false;
+  }
+  if (!aiEnabled) {
+    return true;
+  }
+  return Number.isFinite(quality) && quality >= minAiQuality;
+};
 var getEntrySkipReason = ({
   makeOrdersEnabled,
   env,
+  ml,
+  aiEnabled,
   quality,
   minAiQuality
 }) => {
   if (!makeOrdersEnabled) {
     return "MAKE_ORDERS_DISABLED";
   }
-  if (env !== "BACKTEST" && quality != null && Number.isFinite(quality) && quality < minAiQuality) {
+  if (isMlResultUnavailable({ env, ml })) {
+    return "ML_RESULT_UNAVAILABLE";
+  }
+  if (isMlRuntimeGateEnabled({ env, ml }) && ml?.result?.passed === false) {
+    const probability = formatGateNumber(ml.result.probability);
+    const threshold = formatGateNumber(ml.result.threshold);
+    return `ML_THRESHOLD_NOT_MET (${probability} < ${threshold})`;
+  }
+  if (env !== "BACKTEST" && aiEnabled && quality == null) {
+    return "AI_QUALITY_UNAVAILABLE";
+  }
+  if (env !== "BACKTEST" && aiEnabled && quality != null && Number.isFinite(quality) && quality < minAiQuality) {
     return `AI_QUALITY_BELOW_MIN (${quality} < ${minAiQuality})`;
   }
   return "ENTRY_POLICY_BLOCKED";
 };
+var normalizeConfigHookList = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value ? [value] : [];
+};
+var isStrategyDecision = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const kind = value.kind;
+  return kind === "skip" || kind === "entry" || kind === "exit" || kind === "protect";
+};
+var CONFIG_HOOK_STAGES = [
+  "onInit",
+  "onBar",
+  "afterCoreDecision",
+  "afterBarDecision",
+  "onSkip",
+  "beforeClosePosition",
+  "afterEnrichMl",
+  "afterEnrichAi",
+  "beforeEntryGate",
+  "beforePlaceOrder",
+  "afterPlaceOrder"
+];
+var isConfigHookStage = (stage) => CONFIG_HOOK_STAGES.includes(
+  stage
+);
 var buildHookCtx = ({
   connector,
   strategyName,
@@ -391,6 +673,13 @@ var buildHookPolicy = ({
   makeOrdersEnabled,
   minAiQuality
 });
+var shouldRecordRuntimeJournal = ({
+  env,
+  config
+}) => env !== "BACKTEST" && env !== "PARITY" && config.RECORD_RUNTIME_TRADES !== false;
+var isTestConnector = (connector) => Boolean(
+  connector.__tradejsTestConnector
+);
 var buildMlHookContext = ({
   signal,
   env,
@@ -495,6 +784,8 @@ var buildAiHookContext = ({
 };
 var handleExitDecision = async ({
   connector,
+  userName,
+  strategyName,
   symbol,
   decision,
   market,
@@ -507,6 +798,13 @@ var handleExitDecision = async ({
       timestamp: decision.closePlan.timestamp,
       direction: decision.closePlan.direction
     });
+    await markRuntimeTradeClosed({
+      userName,
+      strategy: strategyName,
+      symbol,
+      exitPrice: decision.closePlan.price,
+      exitTimestamp: decision.closePlan.timestamp
+    });
   } catch (err) {
     await onRuntimeError?.({
       stage: "closePosition",
@@ -519,6 +817,33 @@ var handleExitDecision = async ({
   }
   return decision.code;
 };
+var handleProtectDecision = async ({
+  connector,
+  symbol,
+  decision,
+  market,
+  onRuntimeError
+}) => {
+  try {
+    await updatePositionProtection({
+      connector,
+      symbol,
+      direction: decision.protectPlan.direction,
+      takeProfits: decision.protectPlan.takeProfits ?? [],
+      stopLossPrice: decision.protectPlan.stopLossPrice ?? null
+    });
+  } catch (err) {
+    await onRuntimeError?.({
+      stage: "protectPosition",
+      error: err,
+      decision,
+      market
+    });
+    logger3.error("protect position error: %s %s", symbol, err);
+    return "ORDER_ERROR";
+  }
+  return decision.code;
+};
 var executeEntryDecision = async ({
   connector,
   symbol,
@@ -531,12 +856,13 @@ var executeEntryDecision = async ({
   policy,
   ml,
   ai,
-  invokeHook,
+  recordRuntimeJournal,
+  invokeStageHooks,
   notifyRuntimeError
 }) => {
   const signal = decision.signal;
   const beforePlaceOrder = async () => {
-    await invokeHook(
+    await invokeStageHooks(
       "beforePlaceOrder",
       manifest?.hooks?.beforePlaceOrder,
       {
@@ -567,6 +893,7 @@ var executeEntryDecision = async ({
     if (signal) {
       await executeEntryOrder({
         connector,
+        userName: hookCtx.userName,
         symbol,
         direction: decision.entryContext.direction,
         qty: decision.orderPlan.qty,
@@ -575,9 +902,10 @@ var executeEntryDecision = async ({
         takeProfits: decision.orderPlan.takeProfits,
         stopLossPrice: decision.orderPlan.stopLossPrice,
         signal,
-        beforePlaceOrder
+        beforePlaceOrder,
+        recordRuntimeTrade: recordRuntimeJournal
       });
-      await invokeHook(
+      await invokeStageHooks(
         "afterPlaceOrder",
         manifest?.hooks?.afterPlaceOrder,
         {
@@ -597,18 +925,35 @@ var executeEntryDecision = async ({
       return signal;
     }
     await beforePlaceOrder();
-    await connector.placeOrder(
-      {
+    const orderPlaced = await connector.placeOrder({
+      symbol,
+      qty: decision.orderPlan.qty,
+      price: decision.entryContext.prices.currentPrice,
+      timestamp: decision.entryContext.timestamp,
+      direction: decision.entryContext.direction
+    });
+    if (!orderPlaced) {
+      throw new Error("PLACE_ORDER_FAILED");
+    }
+    try {
+      await updatePositionProtection({
+        connector,
         symbol,
+        direction: decision.entryContext.direction,
         qty: decision.orderPlan.qty,
+        takeProfits: decision.orderPlan.takeProfits,
+        stopLossPrice: decision.orderPlan.stopLossPrice
+      });
+    } catch (error) {
+      await connector.closePosition({
+        symbol,
         price: decision.entryContext.prices.currentPrice,
         timestamp: decision.entryContext.timestamp,
         direction: decision.entryContext.direction
-      },
-      decision.orderPlan.takeProfits,
-      decision.orderPlan.stopLossPrice
-    );
-    await invokeHook(
+      });
+      throw error;
+    }
+    await invokeStageHooks(
       "afterPlaceOrder",
       manifest?.hooks?.afterPlaceOrder,
       {
@@ -658,7 +1003,7 @@ var createStrategyRuntime = ({
     }
     return getStrategyManifest(name, projectRoot);
   };
-  const loadPineScript = createLoadPineScript(
+  const loadPineScriptFile = createPineScriptLoader(
     strategyDirectory ? path.resolve(strategyDirectory) : path.resolve(
       projectRoot,
       "packages",
@@ -684,7 +1029,10 @@ var createStrategyRuntime = ({
       baseConfig,
       defaults
     });
+    const projectConfig = await loadTradejsConfig(projectRoot);
+    const projectHooks = projectConfig.hooks;
     const env = String(config.ENV ?? "BACKTEST");
+    const recordRuntimeJournal = shouldRecordRuntimeJournal({ env, config });
     const strategyManifest = resolveManifest(strategyName);
     const hookBase = {
       connector,
@@ -699,6 +1047,7 @@ var createStrategyRuntime = ({
       ...hookBase,
       strategyName: name
     });
+    const getProjectHookList = (stage) => normalizeConfigHookList(projectHooks?.[stage]);
     const notifyRuntimeError = async ({
       stage,
       error,
@@ -708,21 +1057,33 @@ var createStrategyRuntime = ({
     }) => {
       const errorStrategyName = decision?.kind === "entry" ? decision.entryContext.strategy : strategyName;
       const errorManifest = resolveManifest(errorStrategyName) ?? strategyManifest;
+      const errorParams = {
+        ctx: getHookCtx(errorStrategyName),
+        market,
+        decision,
+        entry,
+        error: {
+          stage,
+          cause: error
+        }
+      };
+      for (const projectHook of getProjectHookList("onRuntimeError")) {
+        try {
+          await projectHook(errorParams);
+        } catch (hookError) {
+          logger3.error(
+            "project hook onRuntimeError failed: %s %s",
+            strategyName,
+            hookError
+          );
+        }
+      }
       const onRuntimeError = errorManifest?.hooks?.onRuntimeError;
       if (!onRuntimeError) {
         return;
       }
       try {
-        await onRuntimeError({
-          ctx: getHookCtx(errorStrategyName),
-          market,
-          decision,
-          entry,
-          error: {
-            stage,
-            cause: error
-          }
-        });
+        await onRuntimeError(errorParams);
       } catch (hookError) {
         logger3.error(
           "runtime hook onRuntimeError failed: %s %s",
@@ -754,6 +1115,126 @@ var createStrategyRuntime = ({
         return void 0;
       }
     };
+    const invokeProjectHooks = async (stage, params, errorContext = {}) => {
+      const results = [];
+      for (const hook of getProjectHookList(stage)) {
+        const result = await invokeHook(
+          stage,
+          hook,
+          params,
+          errorContext
+        );
+        if (result !== void 0) {
+          results.push(result);
+        }
+      }
+      return results;
+    };
+    const invokeStageHooks = async (stage, hook, params, errorContext = {}) => {
+      if (isConfigHookStage(stage)) {
+        await invokeProjectHooks(stage, params, errorContext);
+      }
+      return invokeHook(stage, hook, params, errorContext);
+    };
+    const invokeGateHooks = async (stage, hook, params, errorContext = {}) => {
+      const projectResults = await invokeProjectHooks(
+        stage,
+        params,
+        errorContext
+      );
+      const projectBlock = projectResults.find(
+        (result) => result?.allow === false
+      );
+      if (projectBlock?.allow === false) {
+        return projectBlock;
+      }
+      return invokeHook(
+        stage,
+        hook,
+        params,
+        errorContext
+      );
+    };
+    const applyProjectAfterCoreDecisionHooks = async ({
+      hookCtx,
+      market,
+      decision
+    }) => {
+      let nextDecision = decision;
+      for (const hook of getProjectHookList(
+        "afterCoreDecision"
+      )) {
+        const result = await invokeHook(
+          "afterCoreDecision",
+          hook,
+          {
+            ctx: hookCtx,
+            market,
+            decision: nextDecision
+          },
+          {
+            decision: nextDecision,
+            market
+          }
+        );
+        if (isStrategyDecision(result)) {
+          nextDecision = result;
+        }
+      }
+      return nextDecision;
+    };
+    const applyProjectAfterBarDecisionHooks = async ({
+      hookCtx,
+      market,
+      decision
+    }) => {
+      let nextDecision = decision;
+      for (const hook of getProjectHookList(
+        "afterBarDecision"
+      )) {
+        const result = await invokeHook(
+          "afterBarDecision",
+          hook,
+          {
+            ctx: hookCtx,
+            market,
+            decision: nextDecision
+          },
+          {
+            decision: nextDecision,
+            market
+          }
+        );
+        if (isStrategyDecision(result)) {
+          nextDecision = result;
+        }
+      }
+      return nextDecision;
+    };
+    const applyProjectOnBarHooks = async ({
+      hookCtx,
+      market
+    }) => {
+      for (const hook of getProjectHookList(
+        "onBar"
+      )) {
+        const result = await invokeHook(
+          "onBar",
+          hook,
+          {
+            ctx: hookCtx,
+            market
+          },
+          {
+            market
+          }
+        );
+        if (isStrategyDecision(result)) {
+          return result;
+        }
+      }
+      return void 0;
+    };
     const indicatorsState = createStrategyIndicatorsState({
       env,
       data,
@@ -783,11 +1264,11 @@ var createStrategyRuntime = ({
       connector,
       data,
       btcData,
-      loadPineScript,
+      loadPineScriptFile,
       strategyApi,
       indicatorsState
     });
-    await invokeHook("onInit", strategyManifest?.hooks?.onInit, {
+    await invokeStageHooks("onInit", strategyManifest?.hooks?.onInit, {
       ctx: getHookCtx(),
       market: {
         data,
@@ -802,13 +1283,64 @@ var createStrategyRuntime = ({
         candle,
         btcCandle
       };
-      const decision = await core(candle, btcCandle);
+      const onBarHookCtx = getHookCtx();
+      const projectOnBarDecision = await applyProjectOnBarHooks({
+        hookCtx: onBarHookCtx,
+        market
+      });
+      let decision;
+      let shouldInvokeAfterCoreDecisionHook = false;
+      if (projectOnBarDecision) {
+        decision = projectOnBarDecision;
+      } else {
+        const manifestOnBarDecision = await invokeHook(
+          "onBar",
+          strategyManifest?.hooks?.onBar,
+          {
+            ctx: onBarHookCtx,
+            market
+          },
+          { market }
+        );
+        if (isStrategyDecision(manifestOnBarDecision)) {
+          decision = manifestOnBarDecision;
+        } else {
+          decision = await core(candle, btcCandle);
+          shouldInvokeAfterCoreDecisionHook = true;
+        }
+      }
+      if (shouldInvokeAfterCoreDecisionHook) {
+        const initialDecisionStrategyName = decision.kind === "entry" ? decision.entryContext.strategy : strategyName;
+        decision = await applyProjectAfterCoreDecisionHooks({
+          hookCtx: getHookCtx(initialDecisionStrategyName),
+          market,
+          decision
+        });
+      }
+      const initialAfterBarDecisionStrategyName = decision.kind === "entry" ? decision.entryContext.strategy : strategyName;
+      decision = await applyProjectAfterBarDecisionHooks({
+        hookCtx: getHookCtx(initialAfterBarDecisionStrategyName),
+        market,
+        decision
+      });
       const decisionStrategyName = decision.kind === "entry" ? decision.entryContext.strategy : strategyName;
       const decisionManifest = resolveManifest(decisionStrategyName) ?? strategyManifest;
       const decisionHookCtx = getHookCtx(decisionStrategyName);
+      if (shouldInvokeAfterCoreDecisionHook) {
+        await invokeHook(
+          "afterCoreDecision",
+          decisionManifest?.hooks?.afterCoreDecision,
+          {
+            ctx: decisionHookCtx,
+            market,
+            decision
+          },
+          { decision, market }
+        );
+      }
       await invokeHook(
-        "afterCoreDecision",
-        decisionManifest?.hooks?.afterCoreDecision,
+        "afterBarDecision",
+        decisionManifest?.hooks?.afterBarDecision,
         {
           ctx: decisionHookCtx,
           market,
@@ -817,7 +1349,7 @@ var createStrategyRuntime = ({
         { decision, market }
       );
       if (decision.kind === "skip") {
-        await invokeHook(
+        await invokeStageHooks(
           "onSkip",
           decisionManifest?.hooks?.onSkip,
           {
@@ -829,12 +1361,13 @@ var createStrategyRuntime = ({
         );
         return decision.code;
       }
-      const makeOrdersEnabled = typeof config.MAKE_ORDERS === "boolean" ? config.MAKE_ORDERS : true;
+      const rawMakeOrdersEnabled = typeof config.MAKE_ORDERS === "boolean" ? config.MAKE_ORDERS : true;
+      const makeOrdersEnabled = rawMakeOrdersEnabled && (env !== "PARITY" || isTestConnector(connector));
       if (decision.kind === "exit") {
         if (!makeOrdersEnabled) {
           return decision.code;
         }
-        const closeGate = await invokeHook(
+        const closeGate = await invokeGateHooks(
           "beforeClosePosition",
           decisionManifest?.hooks?.beforeClosePosition,
           {
@@ -849,6 +1382,8 @@ var createStrategyRuntime = ({
         }
         return handleExitDecision({
           connector,
+          userName: recordRuntimeJournal ? userName : void 0,
+          strategyName,
           symbol,
           decision,
           market,
@@ -867,6 +1402,30 @@ var createStrategyRuntime = ({
           }
         });
       }
+      if (decision.kind === "protect") {
+        if (!makeOrdersEnabled) {
+          return decision.code;
+        }
+        return handleProtectDecision({
+          connector,
+          symbol,
+          decision,
+          market,
+          onRuntimeError: async ({
+            stage,
+            error,
+            decision: protectDecision,
+            market: errorMarket
+          }) => {
+            await notifyRuntimeError({
+              stage,
+              error,
+              decision: protectDecision,
+              market: errorMarket
+            });
+          }
+        });
+      }
       const runtime = resolveEntryRuntimePolicy({
         decision,
         config,
@@ -900,7 +1459,7 @@ var createStrategyRuntime = ({
           env,
           ml: runtime.ml
         });
-        await invokeHook(
+        await invokeStageHooks(
           "afterEnrichMl",
           decisionManifest?.hooks?.afterEnrichMl,
           {
@@ -917,8 +1476,13 @@ var createStrategyRuntime = ({
       let ai;
       if (signal) {
         try {
+          await enrichSignalWithDerivativesContext({
+            signal,
+            env
+          });
           quality = await enrichSignalWithAi({
             signal,
+            userName,
             symbol,
             direction: signal.direction,
             env,
@@ -939,7 +1503,7 @@ var createStrategyRuntime = ({
           ai: runtime.ai,
           quality
         });
-        await invokeHook(
+        await invokeStageHooks(
           "afterEnrichAi",
           decisionManifest?.hooks?.afterEnrichAi,
           {
@@ -954,6 +1518,7 @@ var createStrategyRuntime = ({
         );
       }
       const minAiQuality = runtime.ai?.minQuality ?? 4;
+      const aiEnabled = runtime.ai?.enabled !== false && runtime.ai != null;
       const policy = buildHookPolicy({
         quality,
         makeOrdersEnabled,
@@ -963,6 +1528,8 @@ var createStrategyRuntime = ({
         makeOrdersEnabled,
         env,
         signal,
+        ml,
+        aiEnabled,
         quality,
         minAiQuality
       });
@@ -972,13 +1539,15 @@ var createStrategyRuntime = ({
           signal.orderSkipReason = getEntrySkipReason({
             makeOrdersEnabled,
             env,
+            ml,
+            aiEnabled,
             quality,
             minAiQuality
           });
         }
         return signal ?? decision.code;
       }
-      const entryGate = await invokeHook(
+      const entryGate = await invokeGateHooks(
         "beforeEntryGate",
         decisionManifest?.hooks?.beforeEntryGate,
         {
@@ -1012,18 +1581,108 @@ var createStrategyRuntime = ({
         policy,
         ml,
         ai,
-        invokeHook,
+        recordRuntimeJournal,
+        invokeStageHooks,
         notifyRuntimeError
       });
     };
   };
 };
 
-// src/strategies.ts
+// src/strategyHooks/closeOppositePositionsBeforeOpen.ts
+var import_lodash2 = __toESM(require_lodash());
+import { logger as logger4 } from "@tradejs/infra/logger";
+var closeOppositePositionsBeforeOpen = async ({
+  connector,
+  entryContext
+}) => {
+  const {
+    symbol: currentSymbol,
+    direction: currentDirection,
+    timestamp,
+    prices,
+    strategy: strategyName
+  } = entryContext;
+  const price = prices.currentPrice;
+  try {
+    logger4.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
+    );
+    logger4.log(
+      "info",
+      "[%s] open positions found: %s",
+      strategyName,
+      openPositions.length
+    );
+    const oppositePositions = openPositions.filter(
+      (item) => item.symbol !== currentSymbol && item.direction !== currentDirection
+    );
+    if (import_lodash2.default.isEmpty(oppositePositions)) {
+      logger4.log(
+        "info",
+        "[%s] no opposite positions to close before open: %s",
+        strategyName,
+        currentSymbol
+      );
+      return;
+    }
+    for (const position of oppositePositions) {
+      logger4.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
+        });
+        logger4.log(
+          "info",
+          "[%s] opposite position closed: %s",
+          strategyName,
+          position.symbol
+        );
+      } catch (err) {
+        logger4.log(
+          "error",
+          "[%s] failed to close opposite position: %s %s",
+          strategyName,
+          position.symbol,
+          err
+        );
+      }
+    }
+  } catch (err) {
+    logger4.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;
     }
@@ -1033,30 +1692,262 @@ var createCloseOppositeBeforePlaceOrderHook = ({
     });
   };
 };
+
+// src/strategyHooks/shared.ts
+var DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
+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 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
+} = {}) => {
+  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;
+    }
+    return {
+      kind: "protect",
+      code: `${toStrategyCodePrefix(ctx.strategyName)}_MOVE_STOP_TO_BREAK_EVEN`,
+      protectPlan: {
+        direction: currentPosition.direction,
+        stopLossPrice: currentPosition.price
+      }
+    };
+  };
+};
+var createMoveStopToBreakEvenAfterCoreDecisionHook = createMoveStopToBreakEvenOnBarHook;
+
+// src/signalsHooks/closeAllPositionsOnGlobalProfitBeforeSignals.ts
+import { logger as logger5 } 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;
+    }
+    logger5.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) {
+      logger5.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 {
+  DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
   askAI,
   buildAiHumanPrompt,
   buildAiPayload,
+  buildAiPrompts,
   buildAiSystemPrompt,
   closeOppositePositionsBeforeOpen,
+  createCloseAllOnGlobalProfitBeforeSignalsHook,
   createCloseOppositeBeforePlaceOrderHook,
+  createMoveStopToBreakEvenAfterCoreDecisionHook,
+  createMoveStopToBreakEvenOnBarHook,
   createStrategyRuntime,
   enrichSignalWithAi,
   enrichSignalWithMl,
   enrichSignalWithMlAi,
+  ensureAiStrategyPluginsLoaded,
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
   executeEntryOrder,
   getAvailableStrategyNames,
+  getDeterministicAiGateContext,
+  getOpenRouterModelKwargs,
   getRegisteredManifests,
   getRegisteredStrategies,
   getStrategyCreator,
   getStrategyManifest,
   isKnownStrategy,
   registerStrategyEntries,
+  resetAiRuntimeCache,
   resetStrategyRegistryCache,
   resolveStrategyConfig,
+  runAiPrompt,
+  runAiPromptLocal,
   strategies,
   trimSeriesDeep
 };