@tradejs/node 1.0.8 → 1.0.10

package/dist/strategies.mjs

@@ -1,7 +1,9 @@
 import {
   buildMlPayload,
+  enrichSignalWithBinanceMarketContext,
+  enrichSignalWithCoinMarketCapContext,
   enrichSignalWithDerivativesContext
-} from "./chunk-JRRG3YQG.mjs";
+} from "./chunk-37VNDZVX.mjs";
 import {
   require_lodash
 } from "./chunk-KZDHZ56N.mjs";
@@ -13,14 +15,16 @@ import {
   buildAiPayload,
   buildAiPrompts,
   buildAiSystemPrompt,
+  buildCompactAiIndicatorsSnapshot,
   ensureAiStrategyPluginsLoaded,
   getDeterministicAiGateContext,
   getOpenRouterModelKwargs,
   resetAiRuntimeCache,
+  resolveStrategyPolicyProfile,
   runAiPrompt,
   runAiPromptLocal,
   trimSeriesDeep
-} from "./chunk-2JKX3DM7.mjs";
+} from "./chunk-IUZML4RK.mjs";
 import {
   createPineScriptLoader
 } from "./chunk-H6LIYHU4.mjs";
@@ -37,11 +41,11 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-WGOYR6AB.mjs";
+} from "./chunk-QVSMINLG.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
-} from "./chunk-JU77QVJ3.mjs";
+} from "./chunk-WS5DYEVZ.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -51,18 +55,24 @@ export * from "@tradejs/core/strategies";
 
 // src/strategyRuntime.ts
 import path from "path";
-import { SIGNALS_PRELOAD_DAYS } from "@tradejs/core/constants";
+import {
+  BACKTEST_EXECUTION_DELAY_MS,
+  BACKTEST_EXECUTION_INTERVAL
+} from "@tradejs/core/constants";
+import { intervalToMs } from "@tradejs/core/data";
 import {
   buildDefaultIndicatorPeriods,
+  calculateRiskRatio,
   createStrategyAPI,
-  createStrategyIndicatorsState
+  createStrategyIndicatorsState,
+  getSharedStrategyReplayState,
+  resolveBacktestExecutionPrice
 } from "@tradejs/core/strategies";
-import { getTimestamp } from "@tradejs/core/time";
 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 { FEE_PERCENT } from "@tradejs/core/constants";
 import {
   buildMlFeatures,
   buildMlTrainingRow,
@@ -73,10 +83,18 @@ import {
 // 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 } from "@tradejs/infra/redis";
+import {
+  delKey,
+  getData,
+  redisKeys,
+  setData,
+  setHashJsonField
+} from "@tradejs/infra/redis";
 var now = () => Date.now();
-var toOrderId = () => `tjs-${randomUUID().replace(/-/g, "").slice(0, 24).toLowerCase()}`;
+var toRandomOrderSuffix = () => randomUUID().replace(/-/g, "").slice(0, 12).toLowerCase();
 var calculateClosedPnl = ({
   direction,
   entryPrice,
@@ -86,7 +104,13 @@ var calculateClosedPnl = ({
   const pnl = direction === "LONG" ? (exitPrice - entryPrice) * qty : (entryPrice - exitPrice) * qty;
   return Number.isFinite(pnl) ? pnl : null;
 };
-var createRuntimeOrderId = () => toOrderId();
+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) {
@@ -102,13 +126,21 @@ var recordRuntimeTradeOpen = async (params) => {
     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),
+        redisKeys.runtimeActiveTrade(userName, record.symbol, runtimeScopeId),
         { orderId: record.orderId },
         { expire: 0 }
       )
@@ -122,13 +154,13 @@ var recordRuntimeTradeOpen = async (params) => {
   }
   return record;
 };
-var markRuntimeTradeClosed = async (params) => {
-  const { userName, symbol, strategy, exitPrice, exitTimestamp, closedPnl } = params;
+var getActiveRuntimeTrade = async (params) => {
+  const { userName, symbol, accountId, deploymentId } = params;
   if (!userName) {
     return null;
   }
   const activeRef = await getData(
-    redisKeys.runtimeActiveTrade(userName, symbol),
+    redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId),
     null
   );
   const orderId = String(activeRef?.orderId || "").trim();
@@ -140,9 +172,38 @@ var markRuntimeTradeClosed = async (params) => {
     null
   );
   if (!existing) {
-    await delKey(redisKeys.runtimeActiveTrade(userName, symbol));
+    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;
   }
@@ -161,14 +222,28 @@ var markRuntimeTradeClosed = async (params) => {
     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);
   try {
     await Promise.all([
       setData(redisKeys.runtimeTrade(userName, orderId), next, {
         expire: TTL_1M
       }),
-      delKey(redisKeys.runtimeActiveTrade(userName, symbol))
+      setHashJsonField(
+        redisKeys.runtimeTradeBucket(userName, dayKey),
+        orderId,
+        next,
+        { expire: TTL_1M }
+      ),
+      delKey(
+        redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        )
+      )
     ]);
   } catch (error) {
     logger.error(
@@ -207,26 +282,6 @@ var resolveAiQuality = (analysis, direction) => {
   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,
@@ -274,7 +329,7 @@ var enrichSignalWithMl = async ({
     const row = trimMlTrainingRowWindows(fullRow, 5);
     const features = buildMlFeatures(row);
     const mlResult = await fetchMlThreshold({
-      strategy,
+      strategy: ml.modelKey ?? strategy,
       features,
       threshold: ml.mlThreshold,
       projectRoot: getTradejsProjectCwd()
@@ -306,32 +361,13 @@ var enrichSignalWithAi = async ({
     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 gateAnalysis = await runAiPromptLocal(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;
-    }
+    signal.aiAnalysis = gateAnalysis;
     return gateQuality;
   }
   try {
-    const { askAI: askAI2 } = await import("./ai.mjs");
-    const analysis = await askAI2(signal, { userName });
+    const analysis = await askAI(signal, { userName });
     signal.aiAnalysis = analysis;
     return resolveAiQuality(analysis, direction);
   } catch (err) {
@@ -348,10 +384,77 @@ var enrichSignalWithMlAi = async ({
   ml,
   ai
 }) => {
+  await enrichSignalWithBinanceMarketContext({ signal, env });
+  await enrichSignalWithCoinMarketCapContext({ signal, env });
   await enrichSignalWithDerivativesContext({ 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 getArrivalSnapshot = 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 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,
@@ -394,11 +497,19 @@ var executeEntryOrder = async ({
   stopLossPrice,
   signal,
   beforePlaceOrder,
-  recordRuntimeTrade = true
+  recordRuntimeTrade = true,
+  leverage
 }) => {
   await beforePlaceOrder?.();
-  const orderId = signal.orderId || createRuntimeOrderId();
+  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 getArrivalSnapshot({ connector, symbol });
+  const orderSubmitTime = Date.now();
   const orderPlaced = await connector.placeOrder({
     symbol,
     qty,
@@ -406,34 +517,47 @@ var executeEntryOrder = async ({
     isLimit: false,
     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 entryPrice = currentPosition?.price && Number.isFinite(currentPosition.price) ? currentPosition.price : currentPrice;
+  const fillSource = currentPosition?.price && Number.isFinite(currentPosition.price) ? "exchange_position" : orderPlaced ? "requested_price" : "unknown";
+  const entryQty = currentPosition?.qty && Number.isFinite(currentPosition.qty) ? currentPosition.qty : placedQty;
+  const estimatedOpenFee = entryPrice * entryQty * FEE_PERCENT;
+  signal.prices.currentPrice = entryPrice;
+  signal.orderQty = entryQty;
+  signal.orderValue = entryQty * entryPrice;
   if (orderPlaced) {
     try {
       await applyProtectiveOrders({
         connector,
         symbol,
         direction,
-        qty,
+        qty: entryQty,
         takeProfits,
         stopLossPrice
       });
     } catch (error) {
       await connector.closePosition({
         symbol,
-        price: currentPrice,
+        price: entryPrice,
         timestamp,
-        direction
+        direction,
+        signal
       });
       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) {
+    signal.orderFailureReason = void 0;
+  }
   if (orderPlaced && recordRuntimeTrade) {
     await recordRuntimeTradeOpen({
       userName,
@@ -441,10 +565,41 @@ var executeEntryOrder = async ({
       signalId: signal.signalId,
       strategy: signal.strategy,
       symbol,
+      interval: signal.interval,
       direction,
-      qty,
+      qty: entryQty,
       entryPrice,
+      signalTimestamp,
+      signalClosePrice,
+      arrivalSnapshotTime: arrivalSnapshot.arrivalSnapshotTime,
+      arrivalSource: arrivalSnapshot.arrivalSource,
+      arrivalMid: arrivalSnapshot.arrivalMid,
+      bid: arrivalSnapshot.bid,
+      ask: arrivalSnapshot.ask,
+      spreadBps: arrivalSnapshot.spreadBps,
+      orderSubmitTime,
+      orderAckTime,
+      fillAvgPrice: entryPrice,
+      fillSource,
+      fillTime,
+      telemetryQuality: resolveRuntimeTelemetryQuality({
+        signalClosePrice,
+        arrivalMid: arrivalSnapshot.arrivalMid,
+        orderSubmitTime,
+        orderAckTime,
+        fillAvgPrice: entryPrice,
+        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,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
     });
   }
@@ -473,13 +628,14 @@ var updatePositionProtection = async ({
 
 // src/strategyHelpers/config.ts
 var import_lodash = __toESM(require_lodash());
-import { getData as getData2, redisKeys as redisKeys3 } from "@tradejs/infra/redis";
+import { getData as getData2, redisKeys as redisKeys2 } from "@tradejs/infra/redis";
 var resolveStrategyConfig = async ({
   strategyName,
   userName,
   symbol,
   baseConfig,
-  defaults
+  defaults,
+  runtimeConfigId
 }) => {
   const mergeIfNotEmpty = (target, patch) => patch && !import_lodash.default.isEmpty(patch) ? {
     ...target,
@@ -492,35 +648,75 @@ var resolveStrategyConfig = async ({
   let isConfigFromBacktest = false;
   if (config.ENV !== "BACKTEST") {
     const userConfig = await getData2(
-      redisKeys3.strategyConfig(userName, strategyName),
+      runtimeConfigId ? redisKeys2.strategyConfig(userName, strategyName, runtimeConfigId) : redisKeys2.strategyConfig(userName, strategyName),
       {}
     );
     config = mergeIfNotEmpty(config, userConfig);
-    const results = await getData2(
-      redisKeys3.strategyResults(userName, strategyName),
-      {}
-    );
-    const backtestResult = results?.[symbol];
-    if (backtestResult && !import_lodash.default.isEmpty(backtestResult.config)) {
-      config = mergeIfNotEmpty(
-        config,
-        backtestResult.config
+    if (!runtimeConfigId || runtimeConfigId === "config") {
+      const results = await getData2(
+        redisKeys2.strategyResults(userName, strategyName),
+        {}
       );
-      isConfigFromBacktest = true;
+      const backtestResult = results?.[symbol];
+      if (backtestResult && !import_lodash.default.isEmpty(backtestResult.config)) {
+        config = mergeIfNotEmpty(
+          config,
+          backtestResult.config
+        );
+        isConfigFromBacktest = true;
+      }
     }
   }
   return { config, isConfigFromBacktest };
 };
 
 // src/strategyRuntime.ts
+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
+  manifest,
+  policyProfile
 }) => {
-  const manifestDefaults = manifest?.entryRuntimeDefaults;
-  const adapterMl = manifest?.mlAdapter?.mapEntryRuntimeFromConfig?.(config);
-  const adapterAi = manifest?.aiAdapter?.mapEntryRuntimeFromConfig?.(config);
+  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,
@@ -606,6 +802,184 @@ var getEntrySkipReason = ({
   }
   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;
@@ -640,6 +1014,11 @@ var buildHookCtx = ({
   strategyName,
   userName,
   symbol,
+  universe,
+  assetClass,
+  accountId,
+  deploymentId,
+  policyProfileId,
   strategyConfig,
   env,
   isConfigFromBacktest
@@ -648,6 +1027,11 @@ var buildHookCtx = ({
   strategyName,
   userName,
   symbol,
+  ...universe ? { universe } : {},
+  ...assetClass ? { assetClass } : {},
+  ...accountId ? { accountId } : {},
+  ...deploymentId ? { deploymentId } : {},
+  ...policyProfileId ? { policyProfileId } : {},
   strategyConfig,
   env,
   isConfigFromBacktest
@@ -680,6 +1064,10 @@ var shouldRecordRuntimeJournal = ({
 var isTestConnector = (connector) => Boolean(
   connector.__tradejsTestConnector
 );
+var canUseSharedReplayState = ({
+  env,
+  sharedReplayKey
+}) => (env === "BACKTEST" || env === "PARITY") && Boolean(sharedReplayKey);
 var buildMlHookContext = ({
   signal,
   env,
@@ -789,22 +1177,86 @@ var handleExitDecision = async ({
   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
+      direction: decision.closePlan.direction,
+      signal: buildExitOrderSignal({
+        strategyName,
+        symbol,
+        decision
+      })
     });
-    await markRuntimeTradeClosed({
+    const closedTrade = await markRuntimeTradeClosed({
       userName,
       strategy: strategyName,
       symbol,
       exitPrice: decision.closePlan.price,
-      exitTimestamp: decision.closePlan.timestamp
+      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",
@@ -901,6 +1353,7 @@ var executeEntryDecision = async ({
         timestamp: decision.entryContext.timestamp,
         takeProfits: decision.orderPlan.takeProfits,
         stopLossPrice: decision.orderPlan.stopLossPrice,
+        ...Number.isFinite(Number(hookCtx.strategyConfig.LEVERAGE)) ? { leverage: Number(hookCtx.strategyConfig.LEVERAGE) } : {},
         signal,
         beforePlaceOrder,
         recordRuntimeTrade: recordRuntimeJournal
@@ -930,7 +1383,8 @@ var executeEntryDecision = async ({
       qty: decision.orderPlan.qty,
       price: decision.entryContext.prices.currentPrice,
       timestamp: decision.entryContext.timestamp,
-      direction: decision.entryContext.direction
+      direction: decision.entryContext.direction,
+      ...Number.isFinite(Number(hookCtx.strategyConfig.LEVERAGE)) ? { leverage: Number(hookCtx.strategyConfig.LEVERAGE) } : {}
     });
     if (!orderPlaced) {
       throw new Error("PLACE_ORDER_FAILED");
@@ -973,6 +1427,9 @@ var executeEntryDecision = async ({
   } 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",
@@ -991,7 +1448,9 @@ var createStrategyRuntime = ({
   defaults,
   createCore,
   manifest: staticManifest,
-  strategyDirectory
+  strategyDirectory,
+  detectorKey,
+  detectorNoSignalSkipReason
 }) => {
   const projectRoot = getTradejsProjectCwd();
   const resolveManifest = (name) => {
@@ -1012,42 +1471,102 @@ var createStrategyRuntime = ({
       strategyName
     )
   );
-  return async ({
+  const creator = async ({
     userName,
+    connectorName,
     config: baseConfig,
     symbol,
+    universe: requestedUniverse,
+    assetClass,
+    accountId: requestedAccountId,
+    deploymentId: requestedDeploymentId,
+    policyProfileId,
+    runtimeConfigId,
     data,
     btcData,
+    ethData = [],
     btcBinanceData,
     btcCoinbaseData,
-    connector
+    backtestExecutionMarketData,
+    connector,
+    sharedIndicatorsReplayKey,
+    sharedStrategyStateKey,
+    onRuntimeClose
   }) => {
     const { config, isConfigFromBacktest } = await resolveStrategyConfig({
       strategyName,
       userName,
       symbol,
       baseConfig,
-      defaults
+      defaults,
+      runtimeConfigId
     });
+    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) => buildHookCtx({
-      ...hookBase,
-      strategyName: name
-    });
+    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,
@@ -1239,10 +1758,13 @@ var createStrategyRuntime = ({
       env,
       data,
       btcData,
+      ethData,
       btcBinanceData,
       btcCoinbaseData,
-      periods: buildDefaultIndicatorPeriods(config),
-      pluginRegistryScope: projectRoot
+      periods: indicatorPeriods,
+      pluginRegistryScope: projectRoot,
+      sharedReplayKey: indicatorSharedReplayKey,
+      useBtcReference: universe === "crypto"
     });
     const strategyApi = createStrategyAPI({
       strategy: strategyName,
@@ -1252,9 +1774,9 @@ var createStrategyRuntime = ({
       connector,
       cachedData: data,
       indicatorsState,
-      preloadStart: getTimestamp(SIGNALS_PRELOAD_DAYS),
-      backtestPriceMode: config.BACKTEST_PRICE_MODE,
-      isConfigFromBacktest
+      isConfigFromBacktest,
+      sharedReplayKey: strategySharedReplayKey,
+      getSharedReplayState: getSharedStrategyReplayState
     });
     const core = await createCore({
       userName,
@@ -1264,9 +1786,12 @@ var createStrategyRuntime = ({
       connector,
       data,
       btcData,
+      ethData,
       loadPineScriptFile,
       strategyApi,
-      indicatorsState
+      indicatorsState,
+      sharedReplayKey: strategySharedReplayKey,
+      getSharedReplayState: getSharedStrategyReplayState
     });
     await invokeStageHooks("onInit", strategyManifest?.hooks?.onInit, {
       ctx: getHookCtx(),
@@ -1275,10 +1800,147 @@ var createStrategyRuntime = ({
         btcData
       }
     });
-    return async (candle, btcCandle) => {
-      data.push(candle);
-      btcData.push(btcCandle);
-      indicatorsState.setCurrentBar(candle, btcCandle);
+    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) => {
+      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,
+        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
@@ -1305,7 +1967,7 @@ var createStrategyRuntime = ({
         if (isStrategyDecision(manifestOnBarDecision)) {
           decision = manifestOnBarDecision;
         } else {
-          decision = await core(candle, btcCandle);
+          decision = options.coreDecisionOverride ?? await core(candle, btcCandle);
           shouldInvokeAfterCoreDecisionHook = true;
         }
       }
@@ -1387,6 +2049,7 @@ var createStrategyRuntime = ({
           symbol,
           decision,
           market,
+          onRuntimeClose,
           onRuntimeError: async ({
             stage,
             error,
@@ -1429,9 +2092,25 @@ var createStrategyRuntime = ({
       const runtime = resolveEntryRuntimePolicy({
         decision,
         config,
-        manifest: decisionManifest
+        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
@@ -1476,6 +2155,14 @@ var createStrategyRuntime = ({
       let ai;
       if (signal) {
         try {
+          await enrichSignalWithBinanceMarketContext({
+            signal,
+            env
+          });
+          await enrichSignalWithCoinMarketCapContext({
+            signal,
+            env
+          });
           await enrichSignalWithDerivativesContext({
             signal,
             env
@@ -1569,6 +2256,20 @@ var createStrategyRuntime = ({
         }
         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,
@@ -1586,7 +2287,41 @@ var createStrategyRuntime = ({
         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
@@ -1695,6 +2430,7 @@ var createCloseOppositeBeforePlaceOrderHook = ({
 
 // src/strategyHooks/shared.ts
 var DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
+var DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER = 0;
 var DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER = 4;
 var GLOBAL_UNREALIZED_PNL_CLOSE_ALL_CODE = "GLOBAL_UNREALIZED_PNL_TARGET_REACHED_CLOSE_ALL";
 var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
@@ -1723,6 +2459,37 @@ var getPositionStopLossPrice = (position) => {
   );
   return Number.isFinite(signalStopLossPrice) ? signalStopLossPrice : null;
 };
+var getPositionTakeProfitPrice = (position) => {
+  if (!position || typeof position !== "object") {
+    return null;
+  }
+  const directTakeProfitPrice = Number(
+    position.tpPrice ?? position.takeProfitPrice ?? Number.NaN
+  );
+  if (Number.isFinite(directTakeProfitPrice)) {
+    return directTakeProfitPrice;
+  }
+  const signalTakeProfitPrice = Number(
+    position.signal?.prices?.takeProfitPrice ?? Number.NaN
+  );
+  return Number.isFinite(signalTakeProfitPrice) ? signalTakeProfitPrice : null;
+};
+var getBreakEvenStopPrice = ({
+  direction,
+  entryPrice,
+  takeProfitPrice,
+  stopProfitMultiplier
+}) => {
+  if (!Number.isFinite(entryPrice)) {
+    return null;
+  }
+  const normalizedStopProfitMultiplier = Number.isFinite(stopProfitMultiplier) ? Math.min(Math.max(stopProfitMultiplier, 0), 1) : DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER;
+  if (takeProfitPrice == null || !Number.isFinite(takeProfitPrice) || direction === "LONG" && takeProfitPrice <= entryPrice || direction === "SHORT" && takeProfitPrice >= entryPrice) {
+    return entryPrice;
+  }
+  const distanceToTakeProfit = takeProfitPrice - entryPrice;
+  return entryPrice + distanceToTakeProfit * normalizedStopProfitMultiplier;
+};
 var getFavorableMovePct = ({
   direction,
   entryPrice,
@@ -1784,7 +2551,8 @@ var toStrategyCodePrefix = (strategyName) => strategyName === "TrendLine" ? "TRE
 // src/strategyHooks/moveStopToBreakEvenAfterCoreDecision.ts
 var createMoveStopToBreakEvenOnBarHook = ({
   isEnabled = () => true,
-  triggerRiskMultiplier = DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER
+  triggerRiskMultiplier = DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER,
+  stopProfitMultiplier = DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER
 } = {}) => {
   return async ({ ctx, market }) => {
     if (!isEnabled(ctx.strategyConfig)) {
@@ -1824,12 +2592,21 @@ var createMoveStopToBreakEvenOnBarHook = ({
     if (favorableMovePct == null || triggerRiskPct == null || favorableMovePct < triggerRiskPct * triggerRiskMultiplier) {
       return;
     }
+    const stopLossPrice = getBreakEvenStopPrice({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      takeProfitPrice: getPositionTakeProfitPrice(currentPosition),
+      stopProfitMultiplier
+    });
+    if (stopLossPrice == null) {
+      return;
+    }
     return {
       kind: "protect",
       code: `${toStrategyCodePrefix(ctx.strategyName)}_MOVE_STOP_TO_BREAK_EVEN`,
       protectPlan: {
         direction: currentPosition.direction,
-        stopLossPrice: currentPosition.price
+        stopLossPrice
       }
     };
   };
@@ -1921,6 +2698,7 @@ export {
   buildAiPayload,
   buildAiPrompts,
   buildAiSystemPrompt,
+  buildCompactAiIndicatorsSnapshot,
   closeOppositePositionsBeforeOpen,
   createCloseAllOnGlobalProfitBeforeSignalsHook,
   createCloseOppositeBeforePlaceOrderHook,
@@ -1928,6 +2706,8 @@ export {
   createMoveStopToBreakEvenOnBarHook,
   createStrategyRuntime,
   enrichSignalWithAi,
+  enrichSignalWithBinanceMarketContext,
+  enrichSignalWithCoinMarketCapContext,
   enrichSignalWithMl,
   enrichSignalWithMlAi,
   ensureAiStrategyPluginsLoaded,