@tradejs/node 2.0.17 → 2.0.19

package/dist/strategies.mjs

@@ -1,27 +1,6 @@
+import "./chunk-5YNMSWL3.mjs";
 import {
   BINANCE_BREADTH_UNIVERSE_KEYS,
-  buildBinanceBreadthUniverseSnapshot,
-  buildMlPayload,
-  enrichSignalWithBinanceMarketContext,
-  enrichSignalWithCoinMarketCapContext,
-  enrichSignalWithHyperliquidWhaleContext,
-  enrichSignalWithMarketContextStages,
-  getBinanceBreadthUniverseSnapshot,
-  getBinanceBreadthUniverses,
-  getHyperliquidPerpSymbols,
-  getHyperliquidPerpUniverseSnapshot,
-  getHyperliquidWhaleAddresses,
-  getHyperliquidWhaleRegistrySnapshot,
-  getPrimaryBinanceBreadthUniverse,
-  isTrackedHyperliquidPerp,
-  isTrackedHyperliquidWhale,
-  loadHyperliquidWhaleFlowContext,
-  resolveHyperliquidPerpFromSignalSymbol
-} from "./chunk-3BP3ETAD.mjs";
-import {
-  require_lodash
-} from "./chunk-GPR56UYQ.mjs";
-import {
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
   askAI,
@@ -29,2537 +8,57 @@ import {
   buildAiPayload,
   buildAiPrompts,
   buildAiSystemPrompt,
+  buildBinanceBreadthUniverseSnapshot,
   buildCompactAiIndicatorsSnapshot,
+  createStrategyRuntime,
+  enrichSignalWithAi,
+  enrichSignalWithBinanceMarketContext,
+  enrichSignalWithCoinMarketCapContext,
+  enrichSignalWithHyperliquidWhaleContext,
+  enrichSignalWithMl,
+  enrichSignalWithMlAi,
   ensureAiStrategyPluginsLoaded,
-  getDeterministicAiGateContext,
-  getOpenRouterModelKwargs,
-  resetAiRuntimeCache,
-  resolveStrategyPolicyProfile,
-  runAiPrompt,
-  runAiPromptLocal,
-  trimSeriesDeep
-} from "./chunk-WK5EUCX5.mjs";
-import {
-  createPineScriptLoader
-} from "./chunk-IQKMII6L.mjs";
-import "./chunk-5YNMSWL3.mjs";
-import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
+  executeEntryOrder,
   getAvailableStrategyNames,
+  getBinanceBreadthUniverseSnapshot,
+  getBinanceBreadthUniverses,
+  getDeterministicAiGateContext,
+  getHyperliquidPerpSymbols,
+  getHyperliquidPerpUniverseSnapshot,
+  getHyperliquidWhaleAddresses,
+  getHyperliquidWhaleRegistrySnapshot,
+  getOpenRouterModelKwargs,
+  getOrderArrivalSnapshot,
+  getPrimaryBinanceBreadthUniverse,
   getRegisteredManifests,
   getRegisteredStrategies,
   getStrategyCreator,
   getStrategyManifest,
   isKnownStrategy,
+  isTrackedHyperliquidPerp,
+  isTrackedHyperliquidWhale,
   registerStrategyEntries,
+  resetAiRuntimeCache,
   resetStrategyRegistryCache,
-  strategies
-} from "./chunk-QVSMINLG.mjs";
-import {
-  getTradejsProjectCwd,
-  loadTradejsConfig
-} from "./chunk-WS5DYEVZ.mjs";
-import {
-  __toESM
-} from "./chunk-UV2HVMKZ.mjs";
+  resolveHyperliquidPerpFromSignalSymbol,
+  resolveStrategyConfig,
+  runAiPrompt,
+  runAiPromptLocal,
+  strategies,
+  trimSeriesDeep,
+  validateEntryProtectionAtArrival
+} from "./chunk-4AVFJMQL.mjs";
+import "./chunk-WS5DYEVZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 
 // src/strategies.ts
 export * from "@tradejs/core/strategies";
 
-// src/strategyRuntime.ts
-import path from "path";
-import {
-  BACKTEST_EXECUTION_DELAY_MS,
-  BACKTEST_EXECUTION_INTERVAL,
-  BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED
-} from "@tradejs/core/constants";
-import { intervalToMs } from "@tradejs/core/data";
-import {
-  buildDefaultIndicatorPeriods,
-  calculateRiskRatio,
-  createStrategyAPI,
-  createStrategyIndicatorsState,
-  getSharedStrategyReplayState,
-  resolveBacktestExecutionPrice
-} from "@tradejs/core/strategies";
-import { logger as logger3 } from "@tradejs/infra/logger";
-
-// src/strategyHelpers/runtime.ts
-import { logger as logger2 } from "@tradejs/infra/logger";
-import { FEE_PERCENT } from "@tradejs/core/constants";
-import {
-  buildMlFeatures,
-  buildMlTrainingRow,
-  fetchMlThreshold,
-  trimMlTrainingRowWindows
-} from "@tradejs/infra/ml";
-
-// src/runtimeJournal.ts
-import { randomUUID } from "crypto";
-import { TTL_1M } from "@tradejs/core/constants";
-import { getRuntimeStorageDayKey } from "@tradejs/core/time";
-import { createRuntimeOrderLinkPrefix } from "@tradejs/core/trade";
-import { logger } from "@tradejs/infra/logger";
-import {
-  delKey,
-  getData,
-  redisKeys,
-  setData,
-  setHashJsonField
-} from "@tradejs/infra/redis";
-var now = () => Date.now();
-var toRandomOrderSuffix = () => randomUUID().replace(/-/g, "").slice(0, 12).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 = (strategy) => {
-  const prefix = createRuntimeOrderLinkPrefix(strategy);
-  if (prefix === "tjs-") {
-    return `tjs-${randomUUID().replace(/-/g, "").slice(0, 24).toLowerCase()}`;
-  }
-  return `${prefix}${toRandomOrderSuffix()}`;
-};
-var recordRuntimeTradeOpen = async (params) => {
-  const { userName } = params;
-  if (!userName) {
-    return null;
-  }
-  const record = {
-    ...params,
-    entryCount: 1,
-    lastEntryPrice: params.entryPrice,
-    lastEntryQty: params.qty,
-    lastEntryTimestamp: params.entryTimestamp,
-    status: "active",
-    currentPrice: params.entryPrice,
-    currentPnl: 0,
-    closedPnl: null,
-    exitPrice: null,
-    exitTimestamp: null,
-    lastSyncedAt: now()
-  };
-  const dayKey = getRuntimeStorageDayKey(record.entryTimestamp);
-  const runtimeScopeId = record.deploymentId ?? record.accountId;
-  try {
-    await Promise.all([
-      setData(redisKeys.runtimeTrade(userName, record.orderId), record, {
-        expire: 0
-      }),
-      setHashJsonField(
-        redisKeys.runtimeTradeBucket(userName, dayKey),
-        record.orderId,
-        record,
-        { expire: 0 }
-      ),
-      setData(
-        redisKeys.runtimeActiveTrade(userName, record.symbol, runtimeScopeId),
-        { 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 recordRuntimeTradeIncrease = async (params) => {
-  const {
-    userName,
-    strategy,
-    symbol,
-    direction,
-    resultingQty,
-    resultingEntryPrice,
-    addedQty,
-    addedEntryPrice,
-    entryTimestamp,
-    fee,
-    accountId,
-    deploymentId
-  } = params;
-  if (!userName) {
-    return null;
-  }
-  const existing = await getActiveRuntimeTrade({
-    userName,
-    symbol,
-    accountId,
-    deploymentId
-  });
-  if (!existing || existing.strategy !== strategy || existing.direction !== direction) {
-    return null;
-  }
-  const addedFee = typeof fee === "number" && Number.isFinite(fee) ? fee : 0;
-  const openFee = (existing.openFee ?? existing.fee ?? 0) + addedFee;
-  const totalFee = (existing.totalFee ?? existing.fee ?? 0) + addedFee;
-  const next = {
-    ...existing,
-    qty: resultingQty,
-    entryPrice: resultingEntryPrice,
-    entryCount: Math.max(1, existing.entryCount ?? 1) + 1,
-    lastEntryPrice: addedEntryPrice,
-    lastEntryQty: addedQty,
-    lastEntryTimestamp: entryTimestamp,
-    currentPrice: resultingEntryPrice,
-    currentPnl: 0,
-    fee: openFee,
-    openFee,
-    totalFee,
-    lastSyncedAt: now()
-  };
-  const dayKey = getRuntimeStorageDayKey(existing.entryTimestamp);
-  try {
-    await Promise.all([
-      setData(redisKeys.runtimeTrade(userName, existing.orderId), next, {
-        expire: 0
-      }),
-      setHashJsonField(
-        redisKeys.runtimeTradeBucket(userName, dayKey),
-        existing.orderId,
-        next,
-        { expire: 0 }
-      )
-    ]);
-  } catch (error) {
-    logger.error(
-      "runtime trade increase journal failed: %s %s",
-      symbol,
-      error?.message || String(error)
-    );
-  }
-  return next;
-};
-var getActiveRuntimeTrade = async (params) => {
-  const { userName, symbol, accountId, deploymentId } = params;
-  if (!userName) {
-    return null;
-  }
-  const activeRef = await getData(
-    redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId),
-    null
-  );
-  const orderId = String(activeRef?.orderId || "").trim();
-  if (!orderId) {
-    return null;
-  }
-  const existing = await getData(
-    redisKeys.runtimeTrade(userName, orderId),
-    null
-  );
-  if (!existing || existing.status !== "active") {
-    await delKey(
-      redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId)
-    );
-    return null;
-  }
-  return existing;
-};
-var markRuntimeTradeClosed = async (params) => {
-  const {
-    userName,
-    symbol,
-    strategy,
-    exitPrice,
-    exitTimestamp,
-    closedPnl,
-    exitType,
-    accountId,
-    deploymentId
-  } = params;
-  if (!userName) {
-    return null;
-  }
-  const existing = await getActiveRuntimeTrade({
-    userName,
-    symbol,
-    accountId,
-    deploymentId
-  });
-  if (!existing) {
-    return null;
-  }
-  const orderId = existing.orderId;
-  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(),
-    exitType: exitType ?? existing.exitType ?? null,
-    lastSyncedAt: now()
-  };
-  const dayKey = getRuntimeStorageDayKey(existing.entryTimestamp);
-  const closeDayKey = getRuntimeStorageDayKey(next.exitTimestamp);
-  try {
-    await Promise.all([
-      setData(redisKeys.runtimeTrade(userName, orderId), next, {
-        expire: TTL_1M
-      }),
-      setHashJsonField(
-        redisKeys.runtimeTradeBucket(userName, dayKey),
-        orderId,
-        next,
-        { expire: TTL_1M }
-      ),
-      setHashJsonField(
-        redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
-        orderId,
-        next,
-        { expire: TTL_1M }
-      ),
-      delKey(
-        redisKeys.runtimeActiveTrade(
-          userName,
-          symbol,
-          deploymentId ?? accountId
-        )
-      )
-    ]);
-  } 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) => {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
-  };
-  const details = {
-    message: String(error?.message ?? "unknown"),
-    status: error?.status ?? null,
-    code: error?.code ?? null,
-    type: error?.type ?? null,
-    providerError: error?.error ?? null
-  };
-  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 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,
-  ml
-}) => {
-  if (env !== "BACKTEST" && ml && ml.enabled !== false && ml.strategyConfig && typeof ml.mlThreshold === "number") {
-    const strategy = signal.strategy;
-    const fullRow = buildMlTrainingRow(
-      buildMlPayload({
-        signal,
-        context: {
-          strategyConfig: ml.strategyConfig,
-          strategyName: strategy,
-          symbol: signal.symbol
-        }
-      }),
-      null
-    );
-    const row = trimMlTrainingRowWindows(fullRow, 5);
-    const features = buildMlFeatures(row);
-    const mlResult = await fetchMlThreshold({
-      strategy: ml.modelKey ?? strategy,
-      features,
-      threshold: ml.mlThreshold,
-      projectRoot: getTradejsProjectCwd()
-    });
-    if (mlResult) {
-      signal.ml = mlResult;
-    }
-  }
-};
-var enrichSignalWithAi = async ({
-  signal,
-  symbol,
-  userName,
-  direction,
-  env,
-  ai
-}) => {
-  if (ai?.enabled === false) {
-    return void 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 gateAnalysis = await runAiPromptLocal(signal);
-    const gateQuality = resolveAiQuality(gateAnalysis, direction);
-    signal.aiAnalysis = gateAnalysis;
-    return gateQuality;
-  }
-  try {
-    const analysis = await askAI(signal, { userName });
-    signal.aiAnalysis = analysis;
-    return resolveAiQuality(analysis, direction);
-  } catch (err) {
-    logger2.error("AI analysis error: %s %s", symbol, formatAiError(err));
-  }
-  return void 0;
-};
-var enrichSignalWithMlAi = async ({
-  signal,
-  userName,
-  symbol,
-  direction,
-  env,
-  ml,
-  ai
-}) => {
-  await enrichSignalWithMarketContextStages({ signal, env });
-  await enrichSignalWithMl({ signal, env, ml });
-  return enrichSignalWithAi({ signal, userName, symbol, direction, env, ai });
-};
-var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-var getOrderArrivalSnapshot = async ({
-  connector,
-  symbol
-}) => {
-  if (typeof connector.getTopOfBookTicker !== "function") {
-    return {
-      arrivalSnapshotTime: Date.now(),
-      arrivalSource: "unavailable",
-      bid: null,
-      ask: null,
-      arrivalMid: null,
-      spreadBps: null
-    };
-  }
-  try {
-    const ticker = await connector.getTopOfBookTicker(symbol);
-    const arrivalSnapshotTime = toFiniteNumberOrNull(ticker?.timestamp);
-    const bid = toFiniteNumberOrNull(ticker?.bidPrice);
-    const ask = toFiniteNumberOrNull(ticker?.askPrice);
-    const arrivalMid = bid != null && ask != null ? (bid + ask) / 2 : null;
-    const spreadBps = bid != null && ask != null && arrivalMid != null && arrivalMid > 0 ? (ask - bid) / arrivalMid * 1e4 : null;
-    return {
-      arrivalSnapshotTime: arrivalSnapshotTime ?? Date.now(),
-      arrivalSource: "top_of_book",
-      bid,
-      ask,
-      arrivalMid,
-      spreadBps
-    };
-  } catch (error) {
-    logger2.warn(
-      "runtime order arrival snapshot failed: %s %s",
-      symbol,
-      error?.message || String(error)
-    );
-    return {
-      arrivalSnapshotTime: Date.now(),
-      arrivalSource: "top_of_book_error",
-      bid: null,
-      ask: null,
-      arrivalMid: null,
-      spreadBps: null
-    };
-  }
-};
-var validateEntryProtectionAtArrival = ({
-  direction,
-  signalPrice,
-  bid,
-  ask,
-  arrivalMid,
-  takeProfits,
-  stopLossPrice
-}) => {
-  const entryReference = direction === "LONG" ? ask ?? arrivalMid ?? signalPrice : bid ?? arrivalMid ?? signalPrice;
-  const stopReference = direction === "LONG" ? bid ?? arrivalMid ?? signalPrice : ask ?? arrivalMid ?? signalPrice;
-  if (!Number.isFinite(entryReference) || entryReference <= 0 || !Number.isFinite(stopReference) || stopReference <= 0) {
-    throw new Error("INVALID_ENTRY_REFERENCE_AT_ARRIVAL");
-  }
-  for (const takeProfit of takeProfits) {
-    if (!Number.isFinite(takeProfit.price) || takeProfit.price <= 0 || (direction === "LONG" ? takeProfit.price <= entryReference : takeProfit.price >= entryReference)) {
-      throw new Error("TAKE_PROFIT_CROSSED_BEFORE_ENTRY");
-    }
-  }
-  if (stopLossPrice != null && (!Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || (direction === "LONG" ? stopLossPrice >= stopReference : stopLossPrice <= stopReference))) {
-    throw new Error("STOP_LOSS_CROSSED_BEFORE_ENTRY");
-  }
-};
-var resolveRuntimeTelemetryQuality = ({
-  signalClosePrice,
-  arrivalMid,
-  orderSubmitTime,
-  orderAckTime,
-  fillAvgPrice,
-  fillTime
-}) => {
-  if (signalClosePrice != null && arrivalMid != null && orderSubmitTime != null && orderAckTime != null && fillAvgPrice != null && fillTime != null) {
-    return "full";
-  }
-  if (fillAvgPrice != null && (arrivalMid != null || orderSubmitTime != null)) {
-    return "partial";
-  }
-  if (fillAvgPrice != null) {
-    return "price_only";
-  }
-  return "none";
-};
-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,
-  currentPrice,
-  timestamp,
-  takeProfits,
-  stopLossPrice,
-  positionIntent = "open",
-  signal,
-  beforePlaceOrder,
-  recordRuntimeTrade = true,
-  leverage
-}) => {
-  await beforePlaceOrder?.();
-  const previousPosition = positionIntent === "increase" ? await connector.getPosition(symbol) : null;
-  const orderId = signal.orderId || createRuntimeOrderId(signal.strategy);
-  const signalTimestamp = signal.timestamp;
-  const signalClosePrice = currentPrice;
-  signal.orderId = orderId;
-  signal.orderQty = qty;
-  signal.orderValue = qty * currentPrice;
-  signal.orderFailureReason = void 0;
-  const arrivalSnapshot = await getOrderArrivalSnapshot({ connector, symbol });
-  try {
-    validateEntryProtectionAtArrival({
-      direction,
-      signalPrice: currentPrice,
-      bid: arrivalSnapshot.bid,
-      ask: arrivalSnapshot.ask,
-      arrivalMid: arrivalSnapshot.arrivalMid,
-      takeProfits,
-      stopLossPrice
-    });
-  } catch (error) {
-    signal.orderStatus = "failed";
-    signal.orderFailureReason = error.message;
-    throw error;
-  }
-  const orderSubmitTime = Date.now();
-  const orderPlaced = await connector.placeOrder({
-    symbol,
-    qty,
-    price: currentPrice,
-    isLimit: false,
-    positionIntent,
-    timestamp,
-    direction,
-    ...typeof leverage === "number" && Number.isFinite(leverage) ? { leverage } : {},
-    orderId,
-    signal
-  });
-  const orderAckTime = Date.now();
-  const placedQty = typeof signal.orderQty === "number" && Number.isFinite(signal.orderQty) && signal.orderQty > 0 ? signal.orderQty : qty;
-  const currentPosition = await connector.getPosition(symbol);
-  const fillTime = Date.now();
-  const isPositionIncrease = positionIntent === "increase" && previousPosition?.direction === direction && Number.isFinite(previousPosition.qty) && previousPosition.qty > 0;
-  const hasRefreshedIncreasedPosition = Boolean(
-    isPositionIncrease && previousPosition && currentPosition?.qty && currentPosition.qty > previousPosition.qty
-  );
-  const hasUsableCurrentPosition = Boolean(
-    currentPosition && Number.isFinite(currentPosition.price) && Number.isFinite(currentPosition.qty) && (!isPositionIncrease || hasRefreshedIncreasedPosition)
-  );
-  const resultingEntryPrice = hasUsableCurrentPosition && currentPosition ? currentPosition.price : isPositionIncrease && previousPosition ? (previousPosition.price * previousPosition.qty + currentPrice * placedQty) / (previousPosition.qty + placedQty) : currentPrice;
-  const resultingQty = hasUsableCurrentPosition && currentPosition ? currentPosition.qty : isPositionIncrease && previousPosition ? previousPosition.qty + placedQty : placedQty;
-  const filledQty = isPositionIncrease && previousPosition ? hasRefreshedIncreasedPosition && currentPosition ? currentPosition.qty - previousPosition.qty : placedQty : resultingQty;
-  const fillPrice = isPositionIncrease && previousPosition && hasRefreshedIncreasedPosition && currentPosition ? (resultingEntryPrice * currentPosition.qty - previousPosition.price * previousPosition.qty) / (currentPosition.qty - previousPosition.qty) : isPositionIncrease ? currentPrice : resultingEntryPrice;
-  const fillSource = hasUsableCurrentPosition ? "exchange_position" : orderPlaced ? "requested_price" : "unknown";
-  const estimatedOpenFee = fillPrice * filledQty * FEE_PERCENT;
-  signal.prices.currentPrice = fillPrice;
-  signal.orderQty = filledQty;
-  signal.orderValue = filledQty * fillPrice;
-  if (orderPlaced) {
-    try {
-      await applyProtectiveOrders({
-        connector,
-        symbol,
-        direction,
-        qty: resultingQty,
-        takeProfits,
-        stopLossPrice
-      });
-    } catch (error) {
-      await connector.closePosition({
-        symbol,
-        price: resultingEntryPrice,
-        timestamp,
-        direction,
-        signal
-      });
-      throw error;
-    }
-  }
-  signal.orderStatus = orderPlaced ? "completed" : "failed";
-  signal.orderSkipReason = void 0;
-  if (orderPlaced) {
-    signal.orderFailureReason = void 0;
-  }
-  if (orderPlaced && recordRuntimeTrade && !isPositionIncrease) {
-    await recordRuntimeTradeOpen({
-      userName,
-      orderId,
-      signalId: signal.signalId,
-      strategy: signal.strategy,
-      symbol,
-      interval: signal.interval,
-      direction,
-      qty: resultingQty,
-      entryPrice: resultingEntryPrice,
-      signalTimestamp,
-      signalClosePrice,
-      arrivalSnapshotTime: arrivalSnapshot.arrivalSnapshotTime,
-      arrivalSource: arrivalSnapshot.arrivalSource,
-      arrivalMid: arrivalSnapshot.arrivalMid,
-      bid: arrivalSnapshot.bid,
-      ask: arrivalSnapshot.ask,
-      spreadBps: arrivalSnapshot.spreadBps,
-      orderSubmitTime,
-      orderAckTime,
-      fillAvgPrice: fillPrice,
-      fillSource,
-      fillTime,
-      telemetryQuality: resolveRuntimeTelemetryQuality({
-        signalClosePrice,
-        arrivalMid: arrivalSnapshot.arrivalMid,
-        orderSubmitTime,
-        orderAckTime,
-        fillAvgPrice: fillPrice,
-        fillTime
-      }),
-      fee: estimatedOpenFee,
-      openFee: estimatedOpenFee,
-      totalFee: estimatedOpenFee,
-      entryTimestamp: timestamp,
-      universe: signal.universe,
-      assetClass: signal.assetClass,
-      accountId: signal.accountId,
-      deploymentId: signal.deploymentId,
-      policyProfileId: signal.policyProfileId,
-      runtimeConfigId: signal.runtimeConfigId,
-      runtimeLineage: signal.runtimeLineage,
-      ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
-    });
-  }
-  if (orderPlaced && recordRuntimeTrade && isPositionIncrease) {
-    await recordRuntimeTradeIncrease({
-      userName,
-      strategy: signal.strategy,
-      symbol,
-      direction,
-      resultingQty,
-      resultingEntryPrice,
-      addedQty: filledQty,
-      addedEntryPrice: fillPrice,
-      entryTimestamp: timestamp,
-      fee: estimatedOpenFee,
-      accountId: signal.accountId,
-      deploymentId: signal.deploymentId
-    });
-  }
-  if (hasUsableCurrentPosition && currentPosition?.price) {
-    return currentPosition.price;
-  }
-  return resultingEntryPrice;
-};
-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_lodash = __toESM(require_lodash());
-import { getData as getData2, redisKeys as redisKeys2 } from "@tradejs/infra/redis";
-var resolveStrategyConfig = async ({
-  strategyName,
-  userName,
-  symbol,
-  baseConfig,
-  defaults,
-  runtimeConfigId,
-  runtimeConfigSnapshot
-}) => {
-  const mergeIfNotEmpty = (target, patch) => patch && !import_lodash.default.isEmpty(patch) ? {
-    ...target,
-    ...patch
-  } : target;
-  let config = {
-    ...defaults,
-    ...baseConfig
-  };
-  let isConfigFromBacktest = false;
-  if (config.ENV !== "BACKTEST") {
-    const userConfig = runtimeConfigSnapshot ? runtimeConfigSnapshot.userConfig : await getData2(
-      runtimeConfigId ? redisKeys2.strategyConfig(
-        userName,
-        strategyName,
-        runtimeConfigId
-      ) : redisKeys2.strategyConfig(userName, strategyName),
-      {}
-    );
-    config = mergeIfNotEmpty(config, userConfig);
-    if (!runtimeConfigId || runtimeConfigId === "config") {
-      const symbolResultConfig = runtimeConfigSnapshot ? runtimeConfigSnapshot.symbolResultConfig : (await getData2(
-        redisKeys2.strategyResults(userName, strategyName),
-        {}
-      ))?.[symbol]?.config;
-      if (symbolResultConfig && !import_lodash.default.isEmpty(symbolResultConfig)) {
-        config = mergeIfNotEmpty(
-          config,
-          symbolResultConfig
-        );
-        isConfigFromBacktest = true;
-      }
-    }
-  }
-  return { config, isConfigFromBacktest };
-};
-
-// src/strategyRuntime.ts
-import {
-  BACKTEST_WARNING_CODES
-} from "@tradejs/types";
-var cloneWithPropertyDescriptors = (value) => Object.create(
-  Object.getPrototypeOf(value),
-  Object.getOwnPropertyDescriptors(value)
-);
-var buildExitOrderSignal = ({
-  strategyName,
-  symbol,
-  decision
-}) => {
-  if (!strategyName) {
-    return void 0;
-  }
-  return {
-    signalId: `${strategyName}:${symbol}:exit:${decision.closePlan.timestamp}`,
-    strategy: strategyName,
-    symbol,
-    interval: "15",
-    direction: decision.closePlan.direction,
-    timestamp: decision.closePlan.timestamp,
-    figures: {},
-    indicators: {},
-    prices: {
-      currentPrice: decision.closePlan.price,
-      takeProfitPrice: decision.closePlan.price,
-      stopLossPrice: decision.closePlan.price,
-      riskRatio: 0
-    },
-    additionalIndicators: {
-      exit: {
-        code: decision.code
-      }
-    }
-  };
-};
-var resolveEntryRuntimePolicy = ({
-  decision,
-  config,
-  manifest,
-  policyProfile
-}) => {
-  const baseDefaults = manifest?.entryRuntimeDefaults;
-  const profileDefaults = policyProfile?.entryRuntimeDefaults;
-  const manifestDefaults = baseDefaults || profileDefaults ? {
-    ...baseDefaults,
-    ...profileDefaults,
-    ...baseDefaults?.ml || profileDefaults?.ml ? { ml: { ...baseDefaults?.ml, ...profileDefaults?.ml } } : {},
-    ...baseDefaults?.ai || profileDefaults?.ai ? { ai: { ...baseDefaults?.ai, ...profileDefaults?.ai } } : {}
-  } : void 0;
-  const adapterMl = (policyProfile?.mlAdapter ?? manifest?.mlAdapter)?.mapEntryRuntimeFromConfig?.(config);
-  const adapterAi = (policyProfile?.aiAdapter ?? manifest?.aiAdapter)?.mapEntryRuntimeFromConfig?.(config);
-  const ml = manifestDefaults?.ml || adapterMl || decision.runtime?.ml ? {
-    ...manifestDefaults?.ml,
-    ...adapterMl,
-    ...decision.runtime?.ml
-  } : void 0;
-  const ai = manifestDefaults?.ai || adapterAi || decision.runtime?.ai ? {
-    ...manifestDefaults?.ai,
-    ...adapterAi,
-    ...decision.runtime?.ai
-  } : void 0;
-  return {
-    ...manifestDefaults,
-    ...decision.runtime,
-    ml,
-    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
-}) => {
-  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 (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 resolveBacktestEntryDelayBars = (value) => {
-  if (value == null || value === "") {
-    return 1;
-  }
-  const parsed = parseInt(String(value), 10);
-  return Number.isFinite(parsed) ? Math.max(0, parsed) : 1;
-};
-var resolveBacktestExecutionIntervalForPrimary = (interval) => {
-  const normalized = String(interval ?? "15");
-  if (normalized === "15") {
-    return BACKTEST_EXECUTION_INTERVAL;
-  }
-  if (normalized === "60") {
-    return "15";
-  }
-  return null;
-};
-var resolveBacktestExecutionDelayMs = (value, fallbackDelayMs) => {
-  if (value == null || value === "") {
-    return fallbackDelayMs;
-  }
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : fallbackDelayMs;
-};
-var safeIntervalToMs = (interval) => {
-  try {
-    return intervalToMs(interval);
-  } catch {
-    return null;
-  }
-};
-var buildCandleByTimestamp = (candles) => new Map(
-  (candles ?? []).filter((candle) => typeof candle?.timestamp === "number").map((candle) => [candle.timestamp, candle])
-);
-var buildBacktestExecutionOnlyCandle = (candle, executionPrice) => ({
-  ...candle,
-  open: executionPrice,
-  high: executionPrice,
-  low: executionPrice,
-  close: executionPrice,
-  volume: 0,
-  turnover: 0
-});
-var resolveInvalidDelayedEntryReason = ({
-  decision,
-  executionPrice,
-  takeProfitPrice,
-  stopLossPrice,
-  riskRatio
-}) => {
-  if (!Number.isFinite(executionPrice) || !Number.isFinite(takeProfitPrice) || !Number.isFinite(stopLossPrice)) {
-    return "BACKTEST_DELAYED_ENTRY_INVALID_PRICE";
-  }
-  if (decision.entryContext.direction === "LONG") {
-    if (executionPrice <= stopLossPrice) {
-      return "BACKTEST_DELAYED_ENTRY_BEYOND_STOP";
-    }
-    if (executionPrice >= takeProfitPrice) {
-      return "BACKTEST_DELAYED_ENTRY_BEYOND_TAKE_PROFIT";
-    }
-    return !Number.isFinite(riskRatio) || riskRatio <= 0 ? "BACKTEST_DELAYED_ENTRY_INVALID_PRICE" : null;
-  }
-  if (executionPrice >= stopLossPrice) {
-    return "BACKTEST_DELAYED_ENTRY_BEYOND_STOP";
-  }
-  if (executionPrice <= takeProfitPrice) {
-    return "BACKTEST_DELAYED_ENTRY_BEYOND_TAKE_PROFIT";
-  }
-  return !Number.isFinite(riskRatio) || riskRatio <= 0 ? "BACKTEST_DELAYED_ENTRY_INVALID_PRICE" : null;
-};
-var applyBacktestDelayedEntryExecution = ({
-  decision,
-  execution,
-  backtestPriceMode,
-  delayBars
-}) => {
-  const { candle, btcCandle } = execution;
-  const signalTimestamp = decision.signal?.timestamp ?? decision.entryContext.timestamp;
-  const signalPrice = decision.signal?.prices.currentPrice ?? decision.entryContext.prices.currentPrice;
-  const skipReason = execution.skipReason ?? (!candle || !btcCandle ? "BACKTEST_LOWER_EXECUTION_CANDLE_MISSING" : void 0);
-  if (skipReason || !candle || !btcCandle) {
-    if (decision.signal) {
-      decision.signal.additionalIndicators = {
-        ...decision.signal.additionalIndicators ?? {},
-        backtestExecution: {
-          entryDelayBars: delayBars,
-          priceMode: backtestPriceMode ?? "open",
-          signalTimestamp,
-          signalPrice,
-          executionSource: execution.source,
-          ...execution.executionInterval ? { executionInterval: execution.executionInterval } : {},
-          ...execution.executionDelayMs != null ? { executionDelayMs: execution.executionDelayMs } : {},
-          ...execution.primaryExecutionTimestamp != null ? { primaryExecutionTimestamp: execution.primaryExecutionTimestamp } : {},
-          ...execution.requestedExecutionTimestamp != null ? {
-            requestedExecutionTimestamp: execution.requestedExecutionTimestamp
-          } : {},
-          skipReason
-        }
-      };
-      decision.signal.orderStatus = "skipped";
-      decision.signal.orderSkipReason = skipReason;
-    }
-    return {
-      skipReason,
-      executionCandle: null,
-      btcExecutionCandle: null
-    };
-  }
-  const executionPrice = resolveBacktestExecutionPrice(
-    candle,
-    backtestPriceMode ?? "open"
-  );
-  const executionTimestamp = candle.timestamp;
-  const takeProfitPrice = decision.entryContext.prices.takeProfitPrice;
-  const stopLossPrice = decision.orderPlan.stopLossPrice;
-  const riskRatio = calculateRiskRatio({
-    direction: decision.entryContext.direction,
-    currentPrice: executionPrice,
-    takeProfitPrice,
-    stopLossPrice
-  });
-  const invalidSkipReason = resolveInvalidDelayedEntryReason({
-    decision,
-    executionPrice,
-    takeProfitPrice,
-    stopLossPrice,
-    riskRatio
-  });
-  decision.entryContext = {
-    ...decision.entryContext,
-    timestamp: executionTimestamp,
-    prices: {
-      ...decision.entryContext.prices,
-      currentPrice: executionPrice,
-      stopLossPrice,
-      riskRatio
-    }
-  };
-  const executionResult = {
-    skipReason: invalidSkipReason,
-    executionCandle: buildBacktestExecutionOnlyCandle(candle, executionPrice),
-    btcExecutionCandle: buildBacktestExecutionOnlyCandle(
-      btcCandle,
-      resolveBacktestExecutionPrice(btcCandle, backtestPriceMode ?? "open")
-    )
-  };
-  if (!decision.signal) {
-    return executionResult;
-  }
-  decision.signal.prices = {
-    ...decision.signal.prices,
-    currentPrice: executionPrice,
-    stopLossPrice,
-    riskRatio
-  };
-  decision.signal.additionalIndicators = {
-    ...decision.signal.additionalIndicators ?? {},
-    backtestExecution: {
-      entryDelayBars: delayBars,
-      priceMode: backtestPriceMode ?? "open",
-      signalTimestamp,
-      signalPrice,
-      executionTimestamp,
-      executionPrice,
-      executionSource: execution.source,
-      ...execution.executionInterval ? { executionInterval: execution.executionInterval } : {},
-      ...execution.executionDelayMs != null ? { executionDelayMs: execution.executionDelayMs } : {},
-      ...execution.primaryExecutionTimestamp != null ? { primaryExecutionTimestamp: execution.primaryExecutionTimestamp } : {},
-      ...execution.requestedExecutionTimestamp != null ? { requestedExecutionTimestamp: execution.requestedExecutionTimestamp } : {},
-      ...invalidSkipReason ? { skipReason: invalidSkipReason } : {}
-    }
-  };
-  if (invalidSkipReason) {
-    decision.signal.orderStatus = "skipped";
-    decision.signal.orderSkipReason = invalidSkipReason;
-  }
-  return executionResult;
-};
-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,
-  userName,
-  symbol,
-  universe,
-  assetClass,
-  accountId,
-  deploymentId,
-  policyProfileId,
-  strategyConfig,
-  env,
-  isConfigFromBacktest
-}) => ({
-  connector,
-  strategyName,
-  userName,
-  symbol,
-  ...universe ? { universe } : {},
-  ...assetClass ? { assetClass } : {},
-  ...accountId ? { accountId } : {},
-  ...deploymentId ? { deploymentId } : {},
-  ...policyProfileId ? { policyProfileId } : {},
-  strategyConfig,
-  env,
-  isConfigFromBacktest
-});
-var buildHookEntry = ({
-  decision,
-  runtime
-}) => ({
-  context: decision.entryContext,
-  orderPlan: decision.orderPlan,
-  signal: decision.signal,
-  runtime: {
-    raw: decision.runtime,
-    resolved: runtime
-  }
-});
-var buildHookPolicy = ({
-  quality,
-  makeOrdersEnabled,
-  minAiQuality
-}) => ({
-  aiQuality: quality,
-  makeOrdersEnabled,
-  minAiQuality
-});
-var shouldRecordRuntimeJournal = ({
-  env,
-  config
-}) => env !== "BACKTEST" && env !== "PARITY" && config.RECORD_RUNTIME_TRADES !== false;
-var isTestConnector = (connector) => Boolean(
-  connector.__tradejsTestConnector
-);
-var canUseSharedReplayState = ({
-  env,
-  sharedReplayKey
-}) => (env === "BACKTEST" || env === "PARITY") && Boolean(sharedReplayKey);
-var buildMlHookContext = ({
-  signal,
-  env,
-  ml
-}) => {
-  if (env === "BACKTEST") {
-    return {
-      config: ml,
-      attempted: false,
-      applied: false,
-      skippedReason: "BACKTEST"
-    };
-  }
-  if (!ml) {
-    return {
-      attempted: false,
-      applied: false,
-      skippedReason: "NO_RUNTIME"
-    };
-  }
-  if (ml.enabled === false) {
-    return {
-      config: ml,
-      attempted: false,
-      applied: false,
-      skippedReason: "DISABLED"
-    };
-  }
-  if (!ml.strategyConfig) {
-    return {
-      config: ml,
-      attempted: false,
-      applied: false,
-      skippedReason: "NO_STRATEGY_CONFIG"
-    };
-  }
-  if (typeof ml.mlThreshold !== "number") {
-    return {
-      config: ml,
-      attempted: false,
-      applied: false,
-      skippedReason: "NO_THRESHOLD"
-    };
-  }
-  if (signal.ml) {
-    return {
-      config: ml,
-      attempted: true,
-      applied: true,
-      result: signal.ml
-    };
-  }
-  return {
-    config: ml,
-    attempted: true,
-    applied: false,
-    skippedReason: "NO_RESULT"
-  };
-};
-var buildAiHookContext = ({
-  env,
-  ai,
-  quality
-}) => {
-  if (env === "BACKTEST") {
-    return {
-      config: ai,
-      attempted: false,
-      applied: false,
-      skippedReason: "BACKTEST"
-    };
-  }
-  if (!ai) {
-    return {
-      attempted: false,
-      applied: false,
-      skippedReason: "NO_RUNTIME"
-    };
-  }
-  if (ai.enabled === false) {
-    return {
-      config: ai,
-      attempted: false,
-      applied: false,
-      skippedReason: "DISABLED"
-    };
-  }
-  if (typeof quality === "number") {
-    return {
-      config: ai,
-      attempted: true,
-      applied: true,
-      quality
-    };
-  }
-  return {
-    config: ai,
-    attempted: true,
-    applied: false,
-    skippedReason: "NO_QUALITY"
-  };
-};
-var handleExitDecision = async ({
-  connector,
-  userName,
-  strategyName,
-  symbol,
-  decision,
-  market,
-  onRuntimeClose,
-  onRuntimeError
-}) => {
-  try {
-    let activeTradeForClose = null;
-    if (userName) {
-      const activeTrade = await getActiveRuntimeTrade({
-        userName,
-        symbol,
-        accountId: connector.accountId,
-        deploymentId: connector.deploymentId
-      });
-      if (!activeTrade) {
-        logger3.warn(
-          "[%s] blocked closePosition for untracked runtime position: %s",
-          strategyName ?? "unknown",
-          symbol
-        );
-        return "CLOSE_BLOCKED_BY_UNTRACKED_POSITION";
-      }
-      if (!strategyName || activeTrade.strategy !== strategyName) {
-        logger3.warn(
-          "[%s] blocked closePosition for foreign runtime position: %s ownedBy=%s",
-          strategyName ?? "unknown",
-          symbol,
-          activeTrade.strategy
-        );
-        return "CLOSE_BLOCKED_BY_FOREIGN_STRATEGY_POSITION";
-      }
-      activeTradeForClose = activeTrade;
-    }
-    await connector.closePosition({
-      symbol,
-      price: decision.closePlan.price,
-      timestamp: decision.closePlan.timestamp,
-      direction: decision.closePlan.direction,
-      signal: buildExitOrderSignal({
-        strategyName,
-        symbol,
-        decision
-      })
-    });
-    const closedTrade = await markRuntimeTradeClosed({
-      userName,
-      strategy: strategyName,
-      symbol,
-      exitPrice: decision.closePlan.price,
-      exitTimestamp: decision.closePlan.timestamp,
-      exitType: "exit",
-      accountId: connector.accountId,
-      deploymentId: connector.deploymentId
-    });
-    const trade = closedTrade ?? activeTradeForClose;
-    if (trade && strategyName) {
-      try {
-        onRuntimeClose?.({
-          userName,
-          strategy: strategyName,
-          openedByStrategy: trade.strategy,
-          symbol,
-          direction: trade.direction,
-          code: decision.code,
-          orderId: trade.orderId,
-          signalId: trade.signalId,
-          qty: trade.qty,
-          entryPrice: trade.entryPrice,
-          entryTimestamp: trade.entryTimestamp,
-          exitPrice: closedTrade?.exitPrice ?? decision.closePlan.price,
-          exitTimestamp: closedTrade?.exitTimestamp ?? decision.closePlan.timestamp,
-          closedPnl: closedTrade?.closedPnl ?? trade.closedPnl ?? null,
-          exitType: closedTrade?.exitType ?? "exit"
-        });
-      } catch (notificationError) {
-        logger3.error(
-          "runtime close notification error: %s %s",
-          symbol,
-          notificationError
-        );
-      }
-    }
-  } catch (err) {
-    await onRuntimeError?.({
-      stage: "closePosition",
-      error: err,
-      decision,
-      market
-    });
-    logger3.error("close order error: %s %s", symbol, err);
-    return "ORDER_ERROR";
-  }
-  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,
-  decision,
-  runtime,
-  manifest,
-  hookCtx,
-  market,
-  entry,
-  policy,
-  ml,
-  ai,
-  recordRuntimeJournal,
-  invokeStageHooks,
-  notifyRuntimeError
-}) => {
-  const signal = decision.signal;
-  const beforePlaceOrder = async () => {
-    await invokeStageHooks(
-      "beforePlaceOrder",
-      manifest?.hooks?.beforePlaceOrder,
-      {
-        ctx: hookCtx,
-        market,
-        decision,
-        entry,
-        policy,
-        ml,
-        ai
-      },
-      { decision, entry, market }
-    );
-    try {
-      await runtime.beforePlaceOrder?.();
-    } catch (error) {
-      await notifyRuntimeError({
-        stage: "runtime.beforePlaceOrder",
-        error,
-        decision,
-        entry,
-        market
-      });
-      throw error;
-    }
-  };
-  try {
-    if (signal) {
-      await executeEntryOrder({
-        connector,
-        userName: hookCtx.userName,
-        symbol,
-        direction: decision.entryContext.direction,
-        qty: decision.orderPlan.qty,
-        currentPrice: decision.entryContext.prices.currentPrice,
-        timestamp: decision.entryContext.timestamp,
-        takeProfits: decision.orderPlan.takeProfits,
-        stopLossPrice: decision.orderPlan.stopLossPrice,
-        positionIntent: decision.orderPlan.positionIntent,
-        ...Number.isFinite(Number(hookCtx.strategyConfig.LEVERAGE)) ? { leverage: Number(hookCtx.strategyConfig.LEVERAGE) } : {},
-        signal,
-        beforePlaceOrder,
-        recordRuntimeTrade: recordRuntimeJournal
-      });
-      await invokeStageHooks(
-        "afterPlaceOrder",
-        manifest?.hooks?.afterPlaceOrder,
-        {
-          ctx: hookCtx,
-          market,
-          decision,
-          entry,
-          policy,
-          ml,
-          ai,
-          order: {
-            result: signal
-          }
-        },
-        { decision, entry, market }
-      );
-      return signal;
-    }
-    await beforePlaceOrder();
-    const arrivalSnapshot = await getOrderArrivalSnapshot({
-      connector,
-      symbol
-    });
-    validateEntryProtectionAtArrival({
-      direction: decision.entryContext.direction,
-      signalPrice: decision.entryContext.prices.currentPrice,
-      bid: arrivalSnapshot.bid,
-      ask: arrivalSnapshot.ask,
-      arrivalMid: arrivalSnapshot.arrivalMid,
-      takeProfits: decision.orderPlan.takeProfits,
-      stopLossPrice: decision.orderPlan.stopLossPrice
-    });
-    const orderPlaced = await connector.placeOrder({
-      symbol,
-      qty: decision.orderPlan.qty,
-      price: decision.entryContext.prices.currentPrice,
-      timestamp: decision.entryContext.timestamp,
-      direction: decision.entryContext.direction,
-      positionIntent: decision.orderPlan.positionIntent,
-      ...Number.isFinite(Number(hookCtx.strategyConfig.LEVERAGE)) ? { leverage: Number(hookCtx.strategyConfig.LEVERAGE) } : {}
-    });
-    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
-      });
-      throw error;
-    }
-    await invokeStageHooks(
-      "afterPlaceOrder",
-      manifest?.hooks?.afterPlaceOrder,
-      {
-        ctx: hookCtx,
-        market,
-        decision,
-        entry,
-        policy,
-        ml,
-        ai,
-        order: {
-          result: decision.code
-        }
-      },
-      { decision, entry, market }
-    );
-  } catch (err) {
-    if (signal) {
-      signal.orderStatus = "failed";
-      if (typeof signal.orderFailureReason !== "string" || !signal.orderFailureReason.trim()) {
-        signal.orderFailureReason = typeof err?.message === "string" && err.message.trim() ? err.message.trim() : void 0;
-      }
-    }
-    await notifyRuntimeError({
-      stage: "placeOrder",
-      error: err,
-      decision,
-      entry,
-      market
-    });
-    if (err?.message === BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
-      logger3.warn("order warning: %s %s", symbol, err);
-    } else {
-      logger3.error("order error: %s %s", symbol, err);
-    }
-    return signal ?? "ORDER_ERROR";
-  }
-  return signal ?? decision.code;
-};
-var createStrategyRuntime = ({
-  strategyName,
-  defaults,
-  createCore,
-  manifest: staticManifest,
-  strategyDirectory,
-  detectorKey,
-  detectorNoSignalSkipReason
-}) => {
-  const projectRoot = getTradejsProjectCwd();
-  const resolveManifest = (name) => {
-    if (!name) {
-      return void 0;
-    }
-    if (staticManifest?.name === name) {
-      return staticManifest;
-    }
-    return getStrategyManifest(name, projectRoot);
-  };
-  const loadPineScriptFile = createPineScriptLoader(
-    strategyDirectory ? path.resolve(strategyDirectory) : path.resolve(
-      projectRoot,
-      "packages",
-      "strategies",
-      "src",
-      strategyName
-    )
-  );
-  const creator = async ({
-    userName,
-    connectorName,
-    config: baseConfig,
-    symbol,
-    universe: requestedUniverse,
-    assetClass,
-    accountId: requestedAccountId,
-    deploymentId: requestedDeploymentId,
-    policyProfileId,
-    runtimeConfigId,
-    runtimeConfigSnapshot,
-    data,
-    btcData,
-    ethData = [],
-    btcBinanceData,
-    btcCoinbaseData,
-    backtestExecutionMarketData,
-    connector,
-    sharedIndicatorsReplayKey,
-    sharedStrategyStateKey,
-    onRuntimeClose
-  }) => {
-    const { config, isConfigFromBacktest } = await resolveStrategyConfig({
-      strategyName,
-      userName,
-      symbol,
-      baseConfig,
-      defaults,
-      runtimeConfigId,
-      runtimeConfigSnapshot
-    });
-    const universe = requestedUniverse ?? connector.universe;
-    const accountId = requestedAccountId ?? connector.accountId;
-    const deploymentId = requestedDeploymentId ?? connector.deploymentId;
-    const projectConfig = await loadTradejsConfig(projectRoot);
-    const projectHooks = projectConfig.hooks;
-    const env = String(config.ENV ?? "BACKTEST");
-    const backtestPriceMode = config.BACKTEST_PRICE_MODE ?? "open";
-    const backtestEntryDelayBars = env === "BACKTEST" ? resolveBacktestEntryDelayBars(config.BACKTEST_ENTRY_DELAY_BARS) : 0;
-    const resolvedBacktestExecutionInterval = config.BACKTEST_EXECUTION_INTERVAL ?? backtestExecutionMarketData?.interval ?? resolveBacktestExecutionIntervalForPrimary(config.INTERVAL ?? "15");
-    const backtestExecutionInterval = resolvedBacktestExecutionInterval == null ? null : String(resolvedBacktestExecutionInterval);
-    const backtestExecutionIntervalLabel = backtestExecutionInterval == null ? void 0 : String(backtestExecutionInterval);
-    const primaryIntervalMs = safeIntervalToMs(config.INTERVAL ?? "15");
-    const backtestExecutionIntervalMs = safeIntervalToMs(
-      backtestExecutionInterval
-    );
-    const backtestExecutionDelayMs = resolveBacktestExecutionDelayMs(
-      config.BACKTEST_EXECUTION_DELAY_MS,
-      backtestExecutionIntervalMs ?? BACKTEST_EXECUTION_DELAY_MS
-    );
-    const backtestExecutionCandleByTimestamp = backtestExecutionMarketData?.dataByTimestamp ?? buildCandleByTimestamp(backtestExecutionMarketData?.data);
-    const backtestExecutionBtcCandleByTimestamp = backtestExecutionMarketData?.btcDataByTimestamp ?? buildCandleByTimestamp(backtestExecutionMarketData?.btcData);
-    const canUseLowerBacktestExecution = env === "BACKTEST" && backtestEntryDelayBars > 0 && backtestExecutionIntervalMs != null && primaryIntervalMs != null && backtestExecutionIntervalMs < primaryIntervalMs;
-    const recordRuntimeJournal = shouldRecordRuntimeJournal({ env, config });
-    const strategyManifest = resolveManifest(strategyName);
-    const requestedPolicyProfileId = policyProfileId ?? (typeof config.POLICY_PROFILE_ID === "string" ? config.POLICY_PROFILE_ID : void 0);
-    const getPolicyProfile = (name = strategyName) => resolveStrategyPolicyProfile(resolveManifest(name), {
-      profileId: requestedPolicyProfileId,
-      universe,
-      assetClass
-    });
-    const strategyPolicyProfile = getPolicyProfile();
-    const indicatorPeriods = buildDefaultIndicatorPeriods(config);
-    const hookBase = {
-      connector,
-      strategyName,
-      userName,
-      symbol,
-      universe,
-      assetClass,
-      accountId,
-      deploymentId,
-      policyProfileId: strategyPolicyProfile?.id ?? requestedPolicyProfileId,
-      strategyConfig: config,
-      env,
-      isConfigFromBacktest
-    };
-    const getHookCtx = (name = strategyName) => {
-      const profile = getPolicyProfile(name);
-      return buildHookCtx({
-        ...hookBase,
-        strategyName: name,
-        policyProfileId: profile?.id ?? requestedPolicyProfileId
-      });
-    };
-    const getProjectHookList = (stage) => normalizeConfigHookList(projectHooks?.[stage]);
-    const indicatorReplayKey = JSON.stringify({
-      periods: indicatorPeriods,
-      universe
-    });
-    const sharedReplayEnabled = canUseSharedReplayState({
-      env,
-      sharedReplayKey: sharedIndicatorsReplayKey
-    });
-    const indicatorSharedReplayKey = sharedReplayEnabled && sharedIndicatorsReplayKey ? `${sharedIndicatorsReplayKey}:indicators:${indicatorReplayKey}` : void 0;
-    const strategyStateBaseKey = env === "CRON" && sharedStrategyStateKey ? sharedStrategyStateKey : sharedReplayEnabled ? sharedIndicatorsReplayKey : void 0;
-    const strategySharedReplayKey = strategyStateBaseKey ? `${strategyStateBaseKey}:strategy:${strategyName}` : void 0;
-    const notifyRuntimeError = async ({
-      stage,
-      error,
-      decision,
-      entry,
-      market
-    }) => {
-      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(errorParams);
-      } catch (hookError) {
-        logger3.error(
-          "runtime hook onRuntimeError failed: %s %s",
-          strategyName,
-          hookError
-        );
-      }
-    };
-    const invokeHook = async (stage, hook, params, errorContext = {}) => {
-      if (!hook) {
-        return void 0;
-      }
-      try {
-        return await hook(params);
-      } catch (error) {
-        logger3.error(
-          'strategy hook "%s" failed for %s: %s',
-          stage,
-          strategyName,
-          error
-        );
-        await notifyRuntimeError({
-          stage,
-          error,
-          decision: errorContext.decision,
-          entry: errorContext.entry,
-          market: errorContext.market
-        });
-        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,
-      btcData,
-      ethData,
-      btcBinanceData,
-      btcCoinbaseData,
-      periods: indicatorPeriods,
-      pluginRegistryScope: projectRoot,
-      sharedReplayKey: indicatorSharedReplayKey,
-      useBtcReference: universe === "crypto"
-    });
-    const coreContextRequirements = new Set(
-      strategyManifest?.contextRequirements?.core ?? []
-    );
-    const strategyApi = createStrategyAPI({
-      strategy: strategyName,
-      symbol,
-      interval: config.INTERVAL ?? "15",
-      env,
-      connector,
-      cachedData: data,
-      indicatorsState,
-      isConfigFromBacktest,
-      sharedReplayKey: strategySharedReplayKey,
-      getSharedReplayState: getSharedStrategyReplayState,
-      loadDecisionBaseContext: async ({
-        baseContext,
-        candle,
-        symbol: decisionSymbol,
-        interval: decisionInterval
-      }) => {
-        if (!baseContext) return void 0;
-        if (!coreContextRequirements.has("hyperliquidWhales")) {
-          return baseContext;
-        }
-        const hyperliquidWhales = await loadHyperliquidWhaleFlowContext({
-          symbol: decisionSymbol,
-          interval: decisionInterval,
-          timestamp: candle.timestamp,
-          env,
-          useSeriesCache: env === "BACKTEST" || env === "PARITY"
-        });
-        if (!hyperliquidWhales) return baseContext;
-        const participation = cloneWithPropertyDescriptors(
-          baseContext.participation
-        );
-        Object.defineProperty(participation, "hyperliquidWhales", {
-          configurable: true,
-          enumerable: true,
-          value: hyperliquidWhales,
-          writable: true
-        });
-        const enrichedBaseContext = cloneWithPropertyDescriptors(baseContext);
-        Object.defineProperty(enrichedBaseContext, "participation", {
-          configurable: true,
-          enumerable: true,
-          value: participation,
-          writable: true
-        });
-        return enrichedBaseContext;
-      }
-    });
-    const core = await createCore({
-      userName,
-      symbol,
-      config,
-      isConfigFromBacktest,
-      connector,
-      data,
-      btcData,
-      ethData,
-      loadPineScriptFile,
-      strategyApi,
-      indicatorsState,
-      sharedReplayKey: strategySharedReplayKey,
-      getSharedReplayState: getSharedStrategyReplayState
-    });
-    await invokeStageHooks("onInit", strategyManifest?.hooks?.onInit, {
-      ctx: getHookCtx(),
-      market: {
-        data,
-        btcData
-      }
-    });
-    const appendCurrentMarketData = (candle, btcCandle, ethCandle) => {
-      if (data[data.length - 1]?.timestamp !== candle.timestamp) {
-        data.push(candle);
-      }
-      if (universe === "crypto" && btcData[btcData.length - 1]?.timestamp !== btcCandle.timestamp) {
-        btcData.push(btcCandle);
-      }
-      if (universe === "crypto" && ethCandle && ethData[ethData.length - 1]?.timestamp !== ethCandle.timestamp) {
-        ethData.push(ethCandle);
-      }
-    };
-    const resolveEthCandle = (candle, ethCandle) => {
-      if (ethCandle?.timestamp === candle.timestamp) {
-        return ethCandle;
-      }
-      const alignedEthCandle = ethData[data.length - 1];
-      if (alignedEthCandle?.timestamp === candle.timestamp) {
-        return alignedEthCandle;
-      }
-      const latestEthCandle = ethData[ethData.length - 1];
-      if (latestEthCandle?.timestamp === candle.timestamp) {
-        return latestEthCandle;
-      }
-      return void 0;
-    };
-    const resolveBacktestExecutionCandle = (candle, btcCandle) => {
-      if (!BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED) {
-        return {
-          candle,
-          btcCandle,
-          source: "primary_timeframe",
-          requestedExecutionTimestamp: candle.timestamp,
-          executionInterval: String(config.INTERVAL ?? "15"),
-          executionDelayMs: 0,
-          primaryExecutionTimestamp: candle.timestamp
-        };
-      }
-      const requestedExecutionTimestamp = candle.timestamp + backtestExecutionDelayMs;
-      const primaryExecutionTimestamp = candle.timestamp;
-      if (!canUseLowerBacktestExecution || primaryIntervalMs == null) {
-        return {
-          source: "lower_timeframe",
-          requestedExecutionTimestamp,
-          executionInterval: backtestExecutionIntervalLabel,
-          executionDelayMs: backtestExecutionDelayMs,
-          primaryExecutionTimestamp,
-          skipReason: "BACKTEST_LOWER_EXECUTION_UNAVAILABLE"
-        };
-      }
-      if (requestedExecutionTimestamp >= candle.timestamp + primaryIntervalMs) {
-        return {
-          source: "lower_timeframe",
-          requestedExecutionTimestamp,
-          executionInterval: backtestExecutionIntervalLabel,
-          executionDelayMs: backtestExecutionDelayMs,
-          primaryExecutionTimestamp,
-          skipReason: "BACKTEST_LOWER_EXECUTION_DELAY_OUT_OF_BAR"
-        };
-      }
-      const lowerCandle = backtestExecutionCandleByTimestamp.get(
-        requestedExecutionTimestamp
-      );
-      const lowerBtcCandle = backtestExecutionBtcCandleByTimestamp.get(
-        requestedExecutionTimestamp
-      );
-      if (lowerCandle && lowerBtcCandle) {
-        return {
-          candle: lowerCandle,
-          btcCandle: lowerBtcCandle,
-          source: "lower_timeframe",
-          requestedExecutionTimestamp,
-          executionInterval: backtestExecutionIntervalLabel,
-          executionDelayMs: backtestExecutionDelayMs,
-          primaryExecutionTimestamp
-        };
-      }
-      return {
-        source: "lower_timeframe",
-        requestedExecutionTimestamp,
-        executionInterval: backtestExecutionIntervalLabel,
-        executionDelayMs: backtestExecutionDelayMs,
-        primaryExecutionTimestamp,
-        skipReason: !lowerCandle ? "BACKTEST_LOWER_EXECUTION_CANDLE_MISSING" : "BACKTEST_LOWER_EXECUTION_BTC_CANDLE_MISSING"
-      };
-    };
-    let pendingBacktestEntry = null;
-    const flushPendingBacktestEntry = async (candle, btcCandle, ethCandle) => {
-      if (!pendingBacktestEntry) {
-        return void 0;
-      }
-      appendCurrentMarketData(candle, btcCandle, ethCandle);
-      const resolvedEthCandle = resolveEthCandle(candle, ethCandle);
-      indicatorsState.setCurrentBar(candle, btcCandle, resolvedEthCandle);
-      pendingBacktestEntry.delayBarsRemaining -= 1;
-      if (pendingBacktestEntry.delayBarsRemaining > 0) {
-        return `BACKTEST_ENTRY_DELAY_PENDING:${pendingBacktestEntry.delayBarsRemaining}`;
-      }
-      const pending = pendingBacktestEntry;
-      pendingBacktestEntry = null;
-      const executionCandleResolution = resolveBacktestExecutionCandle(
-        candle,
-        btcCandle
-      );
-      const execution = applyBacktestDelayedEntryExecution({
-        decision: pending.decision,
-        execution: executionCandleResolution,
-        backtestPriceMode: executionCandleResolution.source === "primary_timeframe" ? "open" : backtestPriceMode,
-        delayBars: pending.delayBars
-      });
-      if (execution.skipReason) {
-        return pending.decision.signal ?? execution.skipReason;
-      }
-      if (!execution.executionCandle || !execution.btcExecutionCandle) {
-        return pending.decision.signal ?? "BACKTEST_LOWER_EXECUTION_CANDLE_MISSING";
-      }
-      const market = {
-        candle: execution.executionCandle,
-        btcCandle: execution.btcExecutionCandle
-      };
-      const entry = buildHookEntry({
-        decision: pending.decision,
-        runtime: pending.runtime
-      });
-      return executeEntryDecision({
-        connector,
-        symbol,
-        decision: pending.decision,
-        runtime: pending.runtime,
-        manifest: pending.manifest,
-        hookCtx: pending.hookCtx,
-        market,
-        entry,
-        policy: pending.policy,
-        ml: pending.ml,
-        ai: pending.ai,
-        recordRuntimeJournal,
-        invokeStageHooks,
-        notifyRuntimeError
-      });
-    };
-    const runWithDecisionOverride = async (candle, btcCandle, options = {}) => {
-      appendCurrentMarketData(candle, btcCandle, options.ethCandle);
-      const ethCandle = resolveEthCandle(candle, options.ethCandle);
-      indicatorsState.setCurrentBar(candle, btcCandle, ethCandle);
-      const delayedEntrySignal = await flushPendingBacktestEntry(
-        candle,
-        btcCandle,
-        ethCandle
-      );
-      if (delayedEntrySignal) {
-        return delayedEntrySignal;
-      }
-      const market = {
-        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 = options.coreDecisionOverride ?? 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(
-        "afterBarDecision",
-        decisionManifest?.hooks?.afterBarDecision,
-        {
-          ctx: decisionHookCtx,
-          market,
-          decision
-        },
-        { decision, market }
-      );
-      if (decision.kind === "skip") {
-        await invokeStageHooks(
-          "onSkip",
-          decisionManifest?.hooks?.onSkip,
-          {
-            ctx: decisionHookCtx,
-            market,
-            decision
-          },
-          { decision, market }
-        );
-        return decision.code;
-      }
-      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 invokeGateHooks(
-          "beforeClosePosition",
-          decisionManifest?.hooks?.beforeClosePosition,
-          {
-            ctx: decisionHookCtx,
-            market,
-            decision
-          },
-          { decision, market }
-        );
-        if (closeGate?.allow === false) {
-          return closeGate.reason ? `CLOSE_BLOCKED_BY_HOOK:${closeGate.reason}` : "CLOSE_BLOCKED_BY_HOOK";
-        }
-        return handleExitDecision({
-          connector,
-          userName: recordRuntimeJournal ? userName : void 0,
-          strategyName,
-          symbol,
-          decision,
-          market,
-          onRuntimeClose,
-          onRuntimeError: async ({
-            stage,
-            error,
-            decision: exitDecision,
-            market: errorMarket
-          }) => {
-            await notifyRuntimeError({
-              stage,
-              error,
-              decision: exitDecision,
-              market: errorMarket
-            });
-          }
-        });
-      }
-      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,
-        manifest: decisionManifest,
-        policyProfile: getPolicyProfile(decisionStrategyName)
-      });
-      const signal = decision.signal;
-      if (signal) {
-        if (universe) signal.universe = universe;
-        if (assetClass) signal.assetClass = assetClass;
-        if (accountId) signal.accountId = accountId;
-        if (deploymentId) signal.deploymentId = deploymentId;
-        if (runtimeConfigId) {
-          signal.runtimeConfigId = runtimeConfigId;
-          if (runtimeConfigId !== "config") {
-            signal.signalId = `${signal.signalId}:${runtimeConfigId}`;
-          }
-        }
-        if (decisionHookCtx.policyProfileId) {
-          signal.policyProfileId = decisionHookCtx.policyProfileId;
-        }
-      }
-      const entry = buildHookEntry({
-        decision,
-        runtime
-      });
-      let ml;
-      if (signal) {
-        try {
-          await enrichSignalWithMl({
-            signal,
-            env,
-            ml: runtime.ml
-          });
-        } catch (error) {
-          await notifyRuntimeError({
-            stage: "enrichSignalWithMl",
-            error,
-            decision,
-            entry,
-            market
-          });
-          throw error;
-        }
-        ml = buildMlHookContext({
-          signal,
-          env,
-          ml: runtime.ml
-        });
-        await invokeStageHooks(
-          "afterEnrichMl",
-          decisionManifest?.hooks?.afterEnrichMl,
-          {
-            ctx: decisionHookCtx,
-            market,
-            decision,
-            entry,
-            ml
-          },
-          { decision, entry, market }
-        );
-      }
-      let quality;
-      let ai;
-      if (signal) {
-        try {
-          await enrichSignalWithMarketContextStages({
-            signal,
-            env,
-            includeHyperliquidWhales: false
-          });
-          quality = await enrichSignalWithAi({
-            signal,
-            userName,
-            symbol,
-            direction: signal.direction,
-            env,
-            ai: runtime.ai
-          });
-        } catch (error) {
-          await notifyRuntimeError({
-            stage: "enrichSignalWithAi",
-            error,
-            decision,
-            entry,
-            market
-          });
-          throw error;
-        }
-        ai = buildAiHookContext({
-          env,
-          ai: runtime.ai,
-          quality
-        });
-        await invokeStageHooks(
-          "afterEnrichAi",
-          decisionManifest?.hooks?.afterEnrichAi,
-          {
-            ctx: decisionHookCtx,
-            market,
-            decision,
-            entry,
-            ml: ml ?? buildMlHookContext({ signal, env, ml: runtime.ml }),
-            ai
-          },
-          { decision, entry, market }
-        );
-      }
-      const minAiQuality = runtime.ai?.minQuality ?? 4;
-      const aiEnabled = runtime.ai?.enabled !== false && runtime.ai != null;
-      const policy = buildHookPolicy({
-        quality,
-        makeOrdersEnabled,
-        minAiQuality
-      });
-      const shouldMakeOrder = shouldExecuteEntryDecision({
-        makeOrdersEnabled,
-        env,
-        signal,
-        ml,
-        aiEnabled,
-        quality,
-        minAiQuality
-      });
-      if (!shouldMakeOrder) {
-        if (signal) {
-          signal.orderStatus = "skipped";
-          signal.orderSkipReason = getEntrySkipReason({
-            makeOrdersEnabled,
-            env,
-            ml,
-            aiEnabled,
-            quality,
-            minAiQuality
-          });
-        }
-        return signal ?? decision.code;
-      }
-      const entryGate = await invokeGateHooks(
-        "beforeEntryGate",
-        decisionManifest?.hooks?.beforeEntryGate,
-        {
-          ctx: decisionHookCtx,
-          market,
-          decision,
-          entry,
-          policy,
-          ml,
-          ai
-        },
-        { decision, entry, market }
-      );
-      if (entryGate?.allow === false) {
-        const skipReason = entryGate.reason ? `HOOK_BEFORE_ENTRY_GATE:${entryGate.reason}` : "HOOK_BEFORE_ENTRY_GATE";
-        if (signal) {
-          signal.orderStatus = "skipped";
-          signal.orderSkipReason = skipReason;
-        }
-        return signal ?? skipReason;
-      }
-      if (backtestEntryDelayBars > 0) {
-        pendingBacktestEntry = {
-          delayBars: backtestEntryDelayBars,
-          delayBarsRemaining: backtestEntryDelayBars,
-          decision,
-          runtime,
-          manifest: decisionManifest,
-          hookCtx: decisionHookCtx,
-          policy,
-          ml,
-          ai
-        };
-        return `BACKTEST_ENTRY_DELAY_QUEUED:${backtestEntryDelayBars}`;
-      }
-      return executeEntryDecision({
-        connector,
-        symbol,
-        decision,
-        runtime,
-        manifest: decisionManifest,
-        hookCtx: decisionHookCtx,
-        market,
-        entry,
-        policy,
-        ml,
-        ai,
-        recordRuntimeJournal,
-        invokeStageHooks,
-        notifyRuntimeError
-      });
-    };
-    const strategy = (async (candle, btcCandle, ethCandle) => runWithDecisionOverride(candle, btcCandle, { ethCandle }));
-    strategy.__tradejsUpdateReferenceData = (params) => indicatorsState.updateReferenceData?.(params);
-    strategy.__tradejsFlushBacktestDelayedEntry = flushPendingBacktestEntry;
-    const resolvedDetectorKey = detectorKey?.(config);
-    if (resolvedDetectorKey && detectorNoSignalSkipReason) {
-      const canFastAdvanceDetectorNoSignal = env === "BACKTEST" && getProjectHookList("onBar").length === 0 && getProjectHookList("afterCoreDecision").length === 0 && getProjectHookList("afterBarDecision").length === 0 && getProjectHookList("onSkip").length === 0 && !strategyManifest?.hooks?.onBar && !strategyManifest?.hooks?.afterCoreDecision && !strategyManifest?.hooks?.afterBarDecision && !strategyManifest?.hooks?.onSkip;
-      strategy.detectorFanoutKey = [strategyName, resolvedDetectorKey].join(
-        ":"
-      );
-      strategy.detectorNoSignalSkipReason = detectorNoSignalSkipReason;
-      strategy.canFastAdvanceDetectorNoSignal = canFastAdvanceDetectorNoSignal;
-      if (canFastAdvanceDetectorNoSignal) {
-        strategy.advanceDetectorNoSignal = (candle, btcCandle, code) => {
-          appendCurrentMarketData(candle, btcCandle);
-          indicatorsState.setCurrentBar(
-            candle,
-            btcCandle,
-            resolveEthCandle(candle)
-          );
-          return Promise.resolve(code);
-        };
-      }
-      strategy.skipDetectorNoSignal = (candle, btcCandle, code) => runWithDecisionOverride(candle, btcCandle, {
-        coreDecisionOverride: strategyApi.skip(code)
-      });
-    }
-    return strategy;
-  };
-  if (detectorKey) {
-    creator.detectorKey = detectorKey;
-  }
-  if (detectorNoSignalSkipReason) {
-    creator.detectorNoSignalSkipReason = detectorNoSignalSkipReason;
-  }
-  return creator;
-};
-
 // src/strategyHooks/closeOppositePositionsBeforeOpen.ts
-var import_lodash2 = __toESM(require_lodash());
-import { logger as logger4 } from "@tradejs/infra/logger";
+import _ from "lodash";
+import { logger } from "@tradejs/infra/logger";
 var closeOppositePositionsBeforeOpen = async ({
   connector,
   entryContext
@@ -2573,7 +72,7 @@ var closeOppositePositionsBeforeOpen = async ({
   } = entryContext;
   const price = prices.currentPrice;
   try {
-    logger4.log(
+    logger.log(
       "info",
       "[%s] checking open positions before open: %s %s",
       strategyName,
@@ -2584,7 +83,7 @@ var closeOppositePositionsBeforeOpen = async ({
     const openPositions = (positions || []).filter(
       (item) => item && Number(item.qty) > 0
     );
-    logger4.log(
+    logger.log(
       "info",
       "[%s] open positions found: %s",
       strategyName,
@@ -2593,8 +92,8 @@ var closeOppositePositionsBeforeOpen = async ({
     const oppositePositions = openPositions.filter(
       (item) => item.symbol !== currentSymbol && item.direction !== currentDirection
     );
-    if (import_lodash2.default.isEmpty(oppositePositions)) {
-      logger4.log(
+    if (_.isEmpty(oppositePositions)) {
+      logger.log(
         "info",
         "[%s] no opposite positions to close before open: %s",
         strategyName,
@@ -2603,7 +102,7 @@ var closeOppositePositionsBeforeOpen = async ({
       return;
     }
     for (const position of oppositePositions) {
-      logger4.log(
+      logger.log(
         "info",
         "[%s] closing opposite position: %s %s qty=%s",
         strategyName,
@@ -2618,14 +117,14 @@ var closeOppositePositionsBeforeOpen = async ({
           timestamp,
           direction: position.direction
         });
-        logger4.log(
+        logger.log(
           "info",
           "[%s] opposite position closed: %s",
           strategyName,
           position.symbol
         );
       } catch (err) {
-        logger4.log(
+        logger.log(
           "error",
           "[%s] failed to close opposite position: %s %s",
           strategyName,
@@ -2635,7 +134,7 @@ var closeOppositePositionsBeforeOpen = async ({
       }
     }
   } catch (err) {
-    logger4.log(
+    logger.log(
       "error",
       "[%s] failed to load open positions before open: %s %s",
       strategyName,
@@ -2847,7 +346,7 @@ var createMoveStopToBreakEvenOnBarHook = ({
 var createMoveStopToBreakEvenAfterCoreDecisionHook = createMoveStopToBreakEvenOnBarHook;
 
 // src/signalsHooks/closeAllPositionsOnGlobalProfitBeforeSignals.ts
-import { logger as logger5 } from "@tradejs/infra/logger";
+import { logger as logger2 } from "@tradejs/infra/logger";
 var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   getStrategyDefaultConfig = () => void 0,
   profitRiskMultiplier = DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER
@@ -2886,7 +385,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
     if (!Number.isFinite(unrealizedPnlThreshold) || unrealizedPnlThreshold <= 0 || totalUnrealizedPnl < unrealizedPnlThreshold) {
       return;
     }
-    logger5.info(
+    logger2.info(
       "closing all positions before signals by global unrealized pnl threshold: totalPnl=%s threshold=%s positions=%s",
       totalUnrealizedPnl,
       unrealizedPnlThreshold,
@@ -2912,7 +411,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
       ];
     });
     if (failedClosures.length) {
-      logger5.warn(
+      logger2.warn(
         "close-all before signals hook could not confirm closures for %s",
         failedClosures.join(", ")
       );