@tradejs/node 2.0.18 → 2.0.19

package/dist/ai.js

@@ -48,7 +48,7 @@ __export(ai_exports, {
 });
 module.exports = __toCommonJS(ai_exports);
 var import_aiLanguages = require("@tradejs/infra/aiLanguages");
-var import_redis = require("@tradejs/infra/redis");
+var import_redis2 = require("@tradejs/infra/redis");
 var import_userSettings = require("@tradejs/infra/userSettings");
 
 // src/aiShared.ts
@@ -624,8 +624,131 @@ var buildAiMarketContext = (signal) => ({
 });
 
 // src/strategy/manifests.ts
-var import_indicators = require("@tradejs/core/indicators");
-var import_logger2 = require("@tradejs/infra/logger");
+var import_indicators2 = require("@tradejs/core/indicators");
+var import_logger11 = require("@tradejs/infra/logger");
+
+// src/strategyRuntime.ts
+var import_constants5 = require("@tradejs/core/constants");
+var import_strategies6 = require("@tradejs/core/strategies");
+var import_logger10 = require("@tradejs/infra/logger");
+
+// src/strategyHelpers/runtime.ts
+var import_logger8 = require("@tradejs/infra/logger");
+var import_constants3 = require("@tradejs/core/constants");
+var import_ml2 = require("@tradejs/infra/ml");
+
+// src/strategy/policyProfiles.ts
+var profileMatches = (profile, universe, assetClass) => {
+  const { appliesTo } = profile;
+  if (!appliesTo) return true;
+  if (appliesTo.universes?.length && (!universe || !appliesTo.universes.includes(universe))) {
+    return false;
+  }
+  if (appliesTo.assetClasses?.length && (!assetClass || !appliesTo.assetClasses.includes(assetClass))) {
+    return false;
+  }
+  return true;
+};
+var resolveStrategyPolicyProfile = (manifest, params) => {
+  const profiles = manifest?.policyProfiles ?? [];
+  if (!profiles.length) {
+    const inferredId = params.profileId ?? (params.universe === "tradfi" ? "tradfi" : void 0);
+    if (!inferredId) return void 0;
+    if (inferredId !== "crypto" && inferredId !== "tradfi") {
+      throw new Error(
+        `Unknown policy profile "${inferredId}" for strategy "${manifest?.name}"`
+      );
+    }
+    if (params.universe && inferredId !== params.universe) {
+      throw new Error(
+        `Policy profile "${inferredId}" is not compatible with ${params.universe}`
+      );
+    }
+    return {
+      id: inferredId,
+      appliesTo: { universes: [inferredId] },
+      marketDataRequirements: inferredId === "crypto" ? ["crypto.btcReference"] : [],
+      ...manifest?.mlAdapter ? {
+        entryRuntimeDefaults: {
+          ml: {
+            modelKey: inferredId === "crypto" ? manifest.name : `${manifest.name}:tradfi`
+          }
+        }
+      } : {}
+    };
+  }
+  if (params.profileId) {
+    const profile = profiles.find(({ id }) => id === params.profileId);
+    if (!profile) {
+      throw new Error(
+        `Unknown policy profile "${params.profileId}" for strategy "${manifest?.name}"`
+      );
+    }
+    if (!profileMatches(profile, params.universe, params.assetClass)) {
+      throw new Error(
+        `Policy profile "${params.profileId}" is not compatible with ${params.universe ?? "unknown"}:${params.assetClass ?? "unknown"}`
+      );
+    }
+    return profile;
+  }
+  const matching = profiles.filter(
+    (profile) => profileMatches(profile, params.universe, params.assetClass)
+  );
+  const defaultProfile = matching.find(
+    ({ id }) => id === manifest?.defaultPolicyProfileId
+  );
+  return defaultProfile ?? matching[0];
+};
+var getStrategyProfileAiAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.aiAdapter ?? manifest?.aiAdapter;
+var getStrategyProfileMlAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.mlAdapter ?? manifest?.mlAdapter;
+
+// src/strategyAdapters/ml.ts
+var defaultMlAdapter = {
+  normalizeStrategyConfig: (strategyConfig) => strategyConfig
+};
+var getStrategyMlAdapter = (strategy, profileId) => {
+  const strategyAdapter = getStrategyProfileMlAdapter(
+    getStrategyManifest(strategy),
+    profileId
+  );
+  if (!strategyAdapter) return defaultMlAdapter;
+  return {
+    ...defaultMlAdapter,
+    ...strategyAdapter
+  };
+};
+
+// src/mlPayload.ts
+var normalizeStrategyConfig = (strategyConfig, strategyName, profileId) => {
+  return getStrategyMlAdapter(
+    strategyName,
+    profileId
+  ).normalizeStrategyConfig?.(strategyConfig);
+};
+var buildMlPayload = (payload) => {
+  const strategyName = payload.signal?.strategy ?? payload.context?.strategyName;
+  const profileId = payload.signal?.policyProfileId;
+  const mlAdapter = getStrategyMlAdapter(strategyName, profileId);
+  const normalizedSignal = mlAdapter.normalizeSignal?.(payload.signal) ?? payload.signal;
+  const nextSignal = {
+    ...normalizedSignal,
+    indicators: {
+      ...normalizedSignal?.indicators ?? {}
+    }
+  };
+  const nextContext = payload.context ? {
+    ...payload.context,
+    strategyConfig: normalizeStrategyConfig(
+      payload.context.strategyConfig,
+      strategyName,
+      profileId
+    )
+  } : void 0;
+  return {
+    signal: nextSignal,
+    context: nextContext
+  };
+};
 
 // src/tradejsConfig.ts
 var import_fs = __toESM(require("fs"));
@@ -912,191 +1035,4663 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
   }
 };
 
-// src/strategy/manifests.ts
-var createStrategyRegistryState = () => ({
-  strategyCreators: /* @__PURE__ */ new Map(),
-  strategyManifestsMap: /* @__PURE__ */ new Map(),
-  pluginsLoadPromise: null
-});
-var registryStateByProjectRoot = /* @__PURE__ */ new Map();
-var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
-  const projectRoot = getTradejsProjectCwd(cwd);
-  let state = registryStateByProjectRoot.get(projectRoot);
-  if (!state) {
-    state = createStrategyRegistryState();
-    registryStateByProjectRoot.set(projectRoot, state);
+// src/runtimeJournal.ts
+var import_node_crypto = require("crypto");
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_trade = require("@tradejs/core/trade");
+var import_logger2 = require("@tradejs/infra/logger");
+var import_redis = require("@tradejs/infra/redis");
+var now = () => Date.now();
+var toRandomOrderSuffix = () => (0, import_node_crypto.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 = (0, import_trade.createRuntimeOrderLinkPrefix)(strategy);
+  if (prefix === "tjs-") {
+    return `tjs-${(0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 24).toLowerCase()}`;
   }
-  return {
-    projectRoot,
-    state
-  };
+  return `${prefix}${toRandomOrderSuffix()}`;
 };
-var toUniqueModules = (modules = []) => [
-  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
-];
-var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
-  const config = await loadTradejsConfig(cwd);
-  return {
-    strategyModules: toUniqueModules(config.strategies),
-    indicatorModules: toUniqueModules(config.indicators)
+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 = (0, import_time.getRuntimeStorageDayKey)(record.entryTimestamp);
+  const runtimeScopeId = record.deploymentId ?? record.accountId;
+  try {
+    await Promise.all([
+      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, record.orderId), record, {
+        expire: 0
+      }),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(userName, dayKey),
+        record.orderId,
+        record,
+        { expire: 0 }
+      ),
+      (0, import_redis.setData)(
+        import_redis.redisKeys.runtimeActiveTrade(userName, record.symbol, runtimeScopeId),
+        { orderId: record.orderId },
+        { expire: 0 }
+      )
+    ]);
+  } catch (error) {
+    import_logger2.logger.error(
+      "runtime trade open journal failed: %s %s",
+      record.symbol,
+      error?.message || String(error)
+    );
+  }
+  return record;
 };
-var extractModuleEntries = (moduleExport, key) => {
-  if (!moduleExport || typeof moduleExport !== "object") {
+var recordRuntimeTradeIncrease = async (params) => {
+  const {
+    userName,
+    strategy,
+    symbol,
+    direction,
+    resultingQty,
+    resultingEntryPrice,
+    addedQty,
+    addedEntryPrice,
+    entryTimestamp,
+    fee,
+    accountId,
+    deploymentId
+  } = params;
+  if (!userName) {
     return null;
   }
-  const candidate = moduleExport;
-  if (Array.isArray(candidate[key])) {
-    return candidate[key];
+  const existing = await getActiveRuntimeTrade({
+    userName,
+    symbol,
+    accountId,
+    deploymentId
+  });
+  if (!existing || existing.strategy !== strategy || existing.direction !== direction) {
+    return null;
   }
-  const defaultExport = candidate.default;
-  if (defaultExport && Array.isArray(defaultExport[key])) {
-    return defaultExport[key];
+  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 = (0, import_time.getRuntimeStorageDayKey)(existing.entryTimestamp);
+  try {
+    await Promise.all([
+      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, existing.orderId), next, {
+        expire: 0
+      }),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(userName, dayKey),
+        existing.orderId,
+        next,
+        { expire: 0 }
+      )
+    ]);
+  } catch (error) {
+    import_logger2.logger.error(
+      "runtime trade increase journal failed: %s %s",
+      symbol,
+      error?.message || String(error)
+    );
   }
-  return null;
+  return next;
 };
-var extractStrategyPluginDefinition = (moduleExport) => {
-  const strategyEntries = extractModuleEntries(
-    moduleExport,
-    "strategyEntries"
+var getActiveRuntimeTrade = async (params) => {
+  const { userName, symbol, accountId, deploymentId } = params;
+  if (!userName) {
+    return null;
+  }
+  const activeRef = await (0, import_redis.getData)(
+    import_redis.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId),
+    null
   );
-  return strategyEntries ? { strategyEntries } : null;
-};
-var extractIndicatorPluginDefinition = (moduleExport) => {
-  const indicatorEntries = extractModuleEntries(
-    moduleExport,
-    "indicatorEntries"
+  const orderId = String(activeRef?.orderId || "").trim();
+  if (!orderId) {
+    return null;
+  }
+  const existing = await (0, import_redis.getData)(
+    import_redis.redisKeys.runtimeTrade(userName, orderId),
+    null
   );
-  return indicatorEntries ? { indicatorEntries } : null;
-};
-var registerEntries = (entries, source, state) => {
-  for (const entry of entries) {
-    const strategyName = entry.manifest?.name;
-    if (!strategyName) {
-      import_logger2.logger.warn("Skip strategy entry without name from %s", source);
-      continue;
-    }
-    if (state.strategyCreators.has(strategyName)) {
-      import_logger2.logger.warn(
-        'Skip duplicate strategy "%s" from %s: already registered',
-        strategyName,
-        source
-      );
-      continue;
-    }
-    state.strategyCreators.set(strategyName, entry.creator);
-    state.strategyManifestsMap.set(strategyName, entry.manifest);
+  if (!existing || existing.status !== "active") {
+    await (0, import_redis.delKey)(
+      import_redis.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId)
+    );
+    return null;
   }
+  return existing;
 };
-var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
-  if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName, cwd);
+var markRuntimeTradeClosed = async (params) => {
+  const {
+    userName,
+    symbol,
+    strategy,
+    exitPrice,
+    exitTimestamp,
+    closedPnl,
+    exitType,
+    accountId,
+    deploymentId
+  } = params;
+  if (!userName) {
+    return null;
   }
-  return import(
-    /* webpackIgnore: true */
-    moduleName
-  );
-};
-var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
-  const { projectRoot, state } = getStrategyRegistryState(cwd);
-  if (!state.pluginsLoadPromise) {
-    (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
-    state.pluginsLoadPromise = (async () => {
-      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
-      const strategySet = new Set(strategyModules);
-      const indicatorSet = new Set(indicatorModules);
-      const pluginModuleNames = [
-        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
-      ];
-      if (!pluginModuleNames.length) {
-        return;
-      }
-      for (const moduleName of pluginModuleNames) {
-        try {
-          const resolvedModuleName = resolvePluginModuleSpecifier(
-            moduleName,
-            projectRoot
-          );
-          const moduleExport = await importStrategyPluginModule(
-            resolvedModuleName,
-            projectRoot
-          );
-          if (strategySet.has(moduleName)) {
-            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
-            if (!pluginDefinition) {
-              import_logger2.logger.warn(
-                'Skip strategy plugin "%s": export { strategyEntries } is missing',
-                moduleName
-              );
-            } else {
-              registerEntries(
-                pluginDefinition.strategyEntries,
-                moduleName,
-                state
-              );
-            }
-          }
-          if (indicatorSet.has(moduleName)) {
-            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
-            if (!indicatorPluginDefinition) {
-              import_logger2.logger.warn(
-                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
-                moduleName
-              );
-            } else {
-              (0, import_indicators.registerIndicatorEntries)(
-                indicatorPluginDefinition.indicatorEntries,
-                moduleName,
-                projectRoot
-              );
-            }
-          }
-          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
-            import_logger2.logger.warn(
-              'Skip plugin "%s": no strategy/indicator sections requested in config',
-              moduleName
-            );
-          }
-        } catch (error) {
-          import_logger2.logger.warn(
-            'Failed to load plugin "%s": %s',
-            moduleName,
-            String(error)
-          );
-        }
-      }
-    })();
+  const existing = await getActiveRuntimeTrade({
+    userName,
+    symbol,
+    accountId,
+    deploymentId
+  });
+  if (!existing) {
+    return null;
   }
-  await state.pluginsLoadPromise;
-};
-var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
-  if (!name) {
-    return void 0;
+  const orderId = existing.orderId;
+  if (strategy && existing.strategy !== strategy) {
+    return null;
   }
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyManifestsMap.get(name);
+  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 = (0, import_time.getRuntimeStorageDayKey)(existing.entryTimestamp);
+  const closeDayKey = (0, import_time.getRuntimeStorageDayKey)(next.exitTimestamp);
+  try {
+    await Promise.all([
+      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, orderId), next, {
+        expire: import_constants.TTL_1M
+      }),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(userName, dayKey),
+        orderId,
+        next,
+        { expire: import_constants.TTL_1M }
+      ),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
+        orderId,
+        next,
+        { expire: import_constants.TTL_1M }
+      ),
+      (0, import_redis.delKey)(
+        import_redis.redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        )
+      )
+    ]);
+  } catch (error) {
+    import_logger2.logger.error(
+      "runtime trade close journal failed: %s %s",
+      symbol,
+      error?.message || String(error)
+    );
+  }
+  return next;
 };
-var strategies = new Proxy(
-  {},
-  {
-    get: (_target, property) => {
-      if (typeof property !== "string") {
-        return void 0;
-      }
-      return getStrategyRegistryState().state.strategyCreators.get(property);
+
+// src/strategyHelpers/marketContextStages.ts
+var import_logger7 = require("@tradejs/infra/logger");
+
+// src/strategyHelpers/binanceMarketContext.ts
+var import_marketContext = require("@tradejs/infra/timescale/marketContext");
+var import_logger3 = require("@tradejs/infra/logger");
+var import_strategies = require("@tradejs/core/strategies");
+
+// src/binanceBreadthUniverses.ts
+var import_node_crypto2 = require("crypto");
+
+// src/config/binanceBreadthUniverses.json
+var binanceBreadthUniverses_default = {
+  schemaVersion: 1,
+  updatedAt: "2026-07-24T15:28:27.234Z",
+  source: "binance_spot_usdt_turnover24h",
+  fingerprint: "43df006e5510bb99",
+  universes: {
+    top5: {
+      size: 5,
+      fingerprint: "ba5b73456b18",
+      symbols: ["ETHUSDT", "USD1USDT", "SOLUSDT", "OPNUSDT", "VANAUSDT"]
     },
-    ownKeys: () => {
-      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    top10: {
+      size: 10,
+      fingerprint: "370eb5af9778",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT"
+      ]
     },
-    getOwnPropertyDescriptor: () => ({
-      enumerable: true,
-      configurable: true
-    })
+    top30: {
+      size: 30,
+      fingerprint: "685a7e7f5fce",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT",
+        "BNBUSDT",
+        "DOGEUSDT",
+        "REUSDT",
+        "RIFUSDT",
+        "ZAMAUSDT",
+        "TRXUSDT",
+        "EURUSDT",
+        "AEROUSDT",
+        "UUSDT",
+        "SUIUSDT",
+        "XAUTUSDT",
+        "NEARUSDT",
+        "LTCUSDT",
+        "SPCXBUSDT",
+        "LAUSDT",
+        "AVAXUSDT",
+        "WLDUSDT",
+        "ONDOUSDT",
+        "XLMUSDT",
+        "UNIUSDT"
+      ]
+    },
+    top50: {
+      size: 50,
+      fingerprint: "cb9725e24141",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT",
+        "BNBUSDT",
+        "DOGEUSDT",
+        "REUSDT",
+        "RIFUSDT",
+        "ZAMAUSDT",
+        "TRXUSDT",
+        "EURUSDT",
+        "AEROUSDT",
+        "UUSDT",
+        "SUIUSDT",
+        "XAUTUSDT",
+        "NEARUSDT",
+        "LTCUSDT",
+        "SPCXBUSDT",
+        "LAUSDT",
+        "AVAXUSDT",
+        "WLDUSDT",
+        "ONDOUSDT",
+        "XLMUSDT",
+        "UNIUSDT",
+        "ADAUSDT",
+        "SNDKBUSDT",
+        "KAITOUSDT",
+        "UTKUSDT",
+        "PEPEUSDT",
+        "WLFIUSDT",
+        "PAXGUSDT",
+        "ENAUSDT",
+        "TAOUSDT",
+        "AAVEUSDT",
+        "CRCLBUSDT",
+        "LINKUSDT",
+        "TONUSDT",
+        "ALLOUSDT",
+        "PUMPUSDT",
+        "INJUSDT",
+        "HOMEUSDT",
+        "MUBUSDT",
+        "TSLABUSDT",
+        "GRAMUSDT"
+      ]
+    },
+    top100: {
+      size: 100,
+      fingerprint: "f397883a81cf",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT",
+        "BNBUSDT",
+        "DOGEUSDT",
+        "REUSDT",
+        "RIFUSDT",
+        "ZAMAUSDT",
+        "TRXUSDT",
+        "EURUSDT",
+        "AEROUSDT",
+        "UUSDT",
+        "SUIUSDT",
+        "XAUTUSDT",
+        "NEARUSDT",
+        "LTCUSDT",
+        "SPCXBUSDT",
+        "LAUSDT",
+        "AVAXUSDT",
+        "WLDUSDT",
+        "ONDOUSDT",
+        "XLMUSDT",
+        "UNIUSDT",
+        "ADAUSDT",
+        "SNDKBUSDT",
+        "KAITOUSDT",
+        "UTKUSDT",
+        "PEPEUSDT",
+        "WLFIUSDT",
+        "PAXGUSDT",
+        "ENAUSDT",
+        "TAOUSDT",
+        "AAVEUSDT",
+        "CRCLBUSDT",
+        "LINKUSDT",
+        "TONUSDT",
+        "ALLOUSDT",
+        "PUMPUSDT",
+        "INJUSDT",
+        "HOMEUSDT",
+        "MUBUSDT",
+        "TSLABUSDT",
+        "GRAMUSDT",
+        "\u5E01\u5B89\u4EBA\u751FUSDT",
+        "SYNUSDT",
+        "TRUMPUSDT",
+        "PROMUSDT",
+        "XPLUSDT",
+        "HBARUSDT",
+        "ERAUSDT",
+        "BCHUSDT",
+        "SOXLBUSDT",
+        "DOTUSDT",
+        "EPICUSDT",
+        "KITEUSDT",
+        "NFPUSDT",
+        "KGSTUSDT",
+        "FILUSDT",
+        "FETUSDT",
+        "KORUBUSDT",
+        "ARBUSDT",
+        "STXUSDT",
+        "HEIUSDT",
+        "BARDUSDT",
+        "DASHUSDT",
+        "ASTERUSDT",
+        "VANRYUSDT",
+        "INTCBUSDT",
+        "ETCUSDT",
+        "EIGENUSDT",
+        "PENGUUSDT",
+        "LRCUSDT",
+        "VIRTUALUSDT",
+        "POLUSDT",
+        "ICPUSDT",
+        "ZBTUSDT",
+        "SKHYBUSDT",
+        "SHIBUSDT",
+        "LDOUSDT",
+        "APTUSDT",
+        "JTOUSDT",
+        "NOMUSDT",
+        "ZROUSDT",
+        "OPUSDT",
+        "BONKUSDT",
+        "SKLUSDT",
+        "HEMIUSDT",
+        "TNSRUSDT",
+        "INTWBUSDT",
+        "BIOUSDT",
+        "TIAUSDT",
+        "ORDIUSDT",
+        "XUSDUSDT"
+      ]
+    }
   }
-);
+};
 
-// src/strategy/policyProfiles.ts
-var getStrategyProfileAiAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.aiAdapter ?? manifest?.aiAdapter;
+// src/binanceBreadthUniverses.ts
+var BINANCE_BREADTH_UNIVERSE_KEYS = [
+  "top5",
+  "top10",
+  "top30",
+  "top50",
+  "top100"
+];
+var fingerprint = (value, length) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
+var normalizeSymbols = (symbols) => symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean);
+var buildBinanceBreadthUniverseSnapshot = ({
+  rankedSymbols,
+  updatedAt = (/* @__PURE__ */ new Date()).toISOString()
+}) => {
+  const uniqueSymbols = [...new Set(normalizeSymbols(rankedSymbols))];
+  if (uniqueSymbols.length < 100) {
+    throw new Error(
+      `Binance breadth snapshot requires at least 100 symbols, got ${uniqueSymbols.length}`
+    );
+  }
+  const universes = Object.fromEntries(
+    BINANCE_BREADTH_UNIVERSE_KEYS.map((key) => {
+      const size = Number(key.slice(3));
+      const symbols = uniqueSymbols.slice(0, size);
+      return [
+        key,
+        {
+          size,
+          fingerprint: fingerprint(symbols, 12),
+          symbols
+        }
+      ];
+    })
+  );
+  return {
+    schemaVersion: 1,
+    updatedAt,
+    source: "binance_spot_usdt_turnover24h",
+    fingerprint: fingerprint(universes, 16),
+    universes
+  };
+};
+var validateSnapshot = (value) => {
+  const rebuilt = buildBinanceBreadthUniverseSnapshot({
+    rankedSymbols: value.universes.top100.symbols,
+    updatedAt: value.updatedAt
+  });
+  if (value.schemaVersion !== 1 || value.source !== rebuilt.source || value.fingerprint !== rebuilt.fingerprint) {
+    throw new Error("Invalid Binance breadth universe snapshot fingerprint");
+  }
+  for (const key of BINANCE_BREADTH_UNIVERSE_KEYS) {
+    const actual = value.universes[key];
+    const expected = rebuilt.universes[key];
+    if (actual.size !== expected.size || actual.fingerprint !== expected.fingerprint || JSON.stringify(actual.symbols) !== JSON.stringify(expected.symbols)) {
+      throw new Error(`Invalid Binance breadth universe snapshot: ${key}`);
+    }
+  }
+  return value;
+};
+var snapshot = validateSnapshot(binanceBreadthUniverses_default);
+var getBinanceBreadthUniverses = () => BINANCE_BREADTH_UNIVERSE_KEYS.map((key) => {
+  const definition = snapshot.universes[key];
+  return {
+    key,
+    size: definition.size,
+    fingerprint: definition.fingerprint,
+    universe: `binance_${key}_usdt_${definition.fingerprint}`,
+    symbols: [...definition.symbols]
+  };
+});
+
+// src/strategyHelpers/marketContextErrors.ts
+var MARKET_CONTEXT_CANCELLATION_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "AbortError",
+  "TimescaleQueryTimeoutError"
+]);
+var isMarketContextCancellationError = (error, abortSignal) => abortSignal?.aborted === true || error instanceof Error && MARKET_CONTEXT_CANCELLATION_ERROR_NAMES.has(error.name);
+
+// src/strategyHelpers/binanceMarketContext.ts
+var DEFAULT_MAX_AGE_BY_INTERVAL = {
+  "1m": 3 * 6e4,
+  "5m": 10 * 6e4,
+  "15m": 30 * 6e4,
+  "1h": 2 * 60 * 6e4
+};
+var binanceMarketContextUnavailable = false;
+var referenceRowsCache = /* @__PURE__ */ new Map();
+var breadthCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized)
+    return env === "BACKTEST" || env === "CRON" || env === "PARITY";
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var toFiniteNumberOrNull = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var signalIntervalToMarketInterval = (value) => {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "5" || normalized === "5m") return "5m";
+  if (normalized === "60" || normalized === "1h") return "1h";
+  return "15m";
+};
+var resolveMarketInterval = (signal, override) => override ?? signalIntervalToMarketInterval(signal.interval);
+var getReferenceSymbols = () => {
+  const symbols = (process.env.BINANCE_MARKET_CONTEXT_REFERENCE_SYMBOLS || "BTCUSDT,ETHUSDT").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+  return symbols.length ? [...new Set(symbols)] : ["BTCUSDT", "ETHUSDT"];
+};
+var resolvePrimaryReferenceSymbol = (signalSymbol) => {
+  const symbol = signalSymbol.trim().toUpperCase();
+  const referenceSymbols = getReferenceSymbols();
+  return referenceSymbols.includes(symbol) ? symbol : referenceSymbols[0];
+};
+var hasBaseContext = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var isBinanceMarketContextEnabled = (env) => parseEnabledFlag(process.env.BINANCE_MARKET_CONTEXT_ENABLED, env);
+var toTradeFlowContext = (row, interval) => row ? {
+  source: "binance_agg_trades",
+  interval,
+  asOfTs: row.ts.getTime(),
+  ageMs: row.ageMs,
+  stale: row.stale,
+  trades: toFiniteNumberOrNull(row.trades),
+  buyPressurePct: toFiniteNumberOrNull(row.buyPressurePct),
+  buyBaseVolume: toFiniteNumberOrNull(row.buyBaseVolume),
+  sellBaseVolume: toFiniteNumberOrNull(row.sellBaseVolume),
+  buyQuoteVolume: toFiniteNumberOrNull(row.buyQuoteVolume),
+  sellQuoteVolume: toFiniteNumberOrNull(row.sellQuoteVolume),
+  netBaseDelta: toFiniteNumberOrNull(row.netBaseDelta),
+  netQuoteDelta: toFiniteNumberOrNull(row.netQuoteDelta)
+} : null;
+var getCachedReferenceRows = ({
+  referenceSymbols,
+  interval,
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${referenceSymbols.join(",")}:${interval}:${timestamp}:${maxAgeMs}`;
+  const cached = referenceRowsCache.get(key);
+  if (cached) return cached;
+  const promise = Promise.all(
+    referenceSymbols.map(async (symbol) => {
+      const tradeFlow = await (0, import_marketContext.getLatestMarketTradeFlow)({
+        symbol,
+        interval,
+        atMs: timestamp,
+        maxAgeMs,
+        ...abortSignal ? { signal: abortSignal } : {}
+      });
+      return {
+        symbol,
+        tradeFlow: toTradeFlowContext(tradeFlow, interval)
+      };
+    })
+  );
+  referenceRowsCache.set(key, promise);
+  void promise.catch(() => referenceRowsCache.delete(key));
+  return promise;
+};
+var getCachedBreadth = ({
+  breadthUniverse,
+  interval,
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${breadthUniverse}:${interval}:${timestamp}:${maxAgeMs}`;
+  const cached = breadthCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_marketContext.getLatestMarketBreadth)({
+    universe: breadthUniverse,
+    interval,
+    atMs: timestamp,
+    maxAgeMs,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  breadthCache.set(key, promise);
+  void promise.catch(() => breadthCache.delete(key));
+  return promise;
+};
+var toMarketBreadthContext = (breadth, interval) => ({
+  source: "binance_klines",
+  universe: breadth.universe,
+  interval,
+  asOfTs: breadth.ts.getTime(),
+  ageMs: breadth.ageMs,
+  stale: breadth.stale,
+  symbolsCount: toFiniteNumberOrNull(breadth.symbolsCount),
+  advancers: toFiniteNumberOrNull(breadth.advancers),
+  decliners: toFiniteNumberOrNull(breadth.decliners),
+  unchanged: toFiniteNumberOrNull(breadth.unchanged),
+  advanceDeclineRatio: toFiniteNumberOrNull(breadth.advanceDeclineRatio),
+  pctAboveMa20: toFiniteNumberOrNull(breadth.pctAboveMa20),
+  pctAboveMa50: toFiniteNumberOrNull(breadth.pctAboveMa50),
+  equalWeightedReturn: toFiniteNumberOrNull(breadth.equalWeightedReturn),
+  volumeWeightedReturn: toFiniteNumberOrNull(breadth.volumeWeightedReturn),
+  dispersion: toFiniteNumberOrNull(breadth.dispersion)
+});
+var enrichSignalWithBinanceMarketContext = async (params) => {
+  const {
+    signal,
+    env,
+    enabled = isBinanceMarketContextEnabled(env),
+    interval = resolveMarketInterval(signal, params.interval),
+    maxAgeMs = DEFAULT_MAX_AGE_BY_INTERVAL[interval]
+  } = params;
+  if (signal.universe === "tradfi" || !enabled || binanceMarketContextUnavailable || !hasBaseContext(signal)) {
+    return false;
+  }
+  try {
+    const referenceSymbols = getReferenceSymbols();
+    const primaryReferenceSymbol = resolvePrimaryReferenceSymbol(signal.symbol);
+    const breadthUniverses = params.breadthUniverse ? [
+      {
+        key: "top30",
+        universe: params.breadthUniverse
+      }
+    ] : getBinanceBreadthUniverses();
+    const [referenceRows, breadthRows] = await Promise.all([
+      getCachedReferenceRows({
+        referenceSymbols,
+        interval,
+        timestamp: signal.timestamp,
+        maxAgeMs,
+        abortSignal: params.abortSignal
+      }),
+      Promise.all(
+        breadthUniverses.map(async ({ key, universe }) => ({
+          key,
+          breadth: await getCachedBreadth({
+            breadthUniverse: universe,
+            interval,
+            timestamp: signal.timestamp,
+            maxAgeMs,
+            abortSignal: params.abortSignal
+          })
+        }))
+      )
+    ]);
+    const availableBreadths = breadthRows.filter(
+      (row) => row.breadth != null
+    );
+    const marketBreadths = Object.fromEntries(
+      availableBreadths.map(({ key, breadth }) => [
+        key,
+        toMarketBreadthContext(breadth, interval)
+      ])
+    );
+    const primaryBreadth = availableBreadths.find(
+      ({ key }) => key === "top30"
+    )?.breadth;
+    const tradeFlowBySymbol = Object.fromEntries(
+      referenceRows.filter((row) => row.tradeFlow).map((row) => [row.symbol, row.tradeFlow])
+    );
+    const targetReferenceSymbol = signal.symbol.trim().toUpperCase();
+    const targetTradeFlow = tradeFlowBySymbol[targetReferenceSymbol];
+    if (!Object.keys(tradeFlowBySymbol).length && !availableBreadths.length) {
+      return false;
+    }
+    const baseContext = signal.additionalIndicators.baseContext;
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators,
+      baseContext: {
+        ...baseContext,
+        participation: {
+          ...baseContext.participation,
+          ...targetTradeFlow ? {
+            tradeFlow: targetTradeFlow
+          } : {}
+        },
+        relative: {
+          ...baseContext.relative,
+          execution: {
+            ...baseContext.relative.execution
+          },
+          ...Object.keys(tradeFlowBySymbol).length ? {
+            referenceTradeFlow: {
+              source: "binance_reference_market",
+              primaryReferenceSymbol,
+              referenceSymbols,
+              tradeFlowBySymbol
+            }
+          } : {},
+          ...availableBreadths.length ? {
+            marketBreadths,
+            ...primaryBreadth ? {
+              marketBreadth: toMarketBreadthContext(
+                primaryBreadth,
+                interval
+              ),
+              btcAltRegime: {
+                source: "binance_klines",
+                universe: primaryBreadth.universe,
+                interval,
+                asOfTs: primaryBreadth.ts.getTime(),
+                ageMs: primaryBreadth.ageMs,
+                stale: primaryBreadth.stale,
+                btcReturn1h: toFiniteNumberOrNull(
+                  primaryBreadth.btcReturn1h
+                ),
+                btcReturn4h: toFiniteNumberOrNull(
+                  primaryBreadth.btcReturn4h
+                ),
+                btcReturn24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcReturn24h
+                ),
+                altBasketReturn1h: toFiniteNumberOrNull(
+                  primaryBreadth.altBasketReturn1h
+                ),
+                altBasketReturn4h: toFiniteNumberOrNull(
+                  primaryBreadth.altBasketReturn4h
+                ),
+                altBasketReturn24h: toFiniteNumberOrNull(
+                  primaryBreadth.altBasketReturn24h
+                ),
+                btcVsAltReturn1h: toFiniteNumberOrNull(
+                  primaryBreadth.btcVsAltReturn1h
+                ),
+                btcVsAltReturn4h: toFiniteNumberOrNull(
+                  primaryBreadth.btcVsAltReturn4h
+                ),
+                btcVsAltReturn24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcVsAltReturn24h
+                ),
+                btcTurnoverShare1h: toFiniteNumberOrNull(
+                  primaryBreadth.btcTurnoverShare1h
+                ),
+                btcTurnoverShare24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcTurnoverShare24h
+                ),
+                btcTurnoverShareChange24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcTurnoverShareChange24h
+                ),
+                altVolToBtcVol24h: toFiniteNumberOrNull(
+                  primaryBreadth.altVolToBtcVol24h
+                ),
+                altDispersion24h: toFiniteNumberOrNull(
+                  primaryBreadth.altDispersion24h
+                ),
+                regime: primaryBreadth.btcAltRegime ?? "unknown"
+              }
+            } : {}
+          } : {}
+        }
+      }
+    };
+    (0, import_strategies.refreshSignalBaseContextGateFeatures)(signal);
+    return true;
+  } catch (error) {
+    if (isMarketContextCancellationError(error, params.abortSignal)) {
+      throw error;
+    }
+    binanceMarketContextUnavailable = true;
+    import_logger3.logger.warn(
+      "Binance market context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyHelpers/coinMarketCapContext.ts
+var import_strategies2 = require("@tradejs/core/strategies");
+var import_logger4 = require("@tradejs/infra/logger");
+var import_marketContext2 = require("@tradejs/infra/timescale/marketContext");
+var DEFAULT_MAX_AGE_MS = 48 * 60 * 6e4;
+var SOURCE_GLOBAL_DAILY = "coinmarketcap_global";
+var SOURCE_REFERENCE = "coinmarketcap_reference_asset";
+var SOURCE_EXCHANGE_LIQUIDITY = "coinmarketcap_exchange_liquidity";
+var SOURCE_FEAR_GREED = "coinmarketcap_fear_greed";
+var SOURCE_INDEX = "coinmarketcap_index";
+var DAY_MS = 864e5;
+var coinMarketCapContextUnavailable = false;
+var globalContextCache = /* @__PURE__ */ new Map();
+var referenceContextCache = /* @__PURE__ */ new Map();
+var exchangeLiquidityContextCache = /* @__PURE__ */ new Map();
+var fearGreedContextCache = /* @__PURE__ */ new Map();
+var indexContextCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag2 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return env === "BACKTEST" || env === "PARITY" || env === "CRON";
+  }
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var toFiniteNumberOrNull2 = (value) => {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var safeDivide = (numerator, denominator) => numerator != null && denominator != null && denominator > 0 ? numerator / denominator : null;
+var hasBaseContext2 = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var resolveMaxAgeMs = () => asInt(process.env.COINMARKETCAP_CONTEXT_MAX_AGE_MS, DEFAULT_MAX_AGE_MS);
+var toAltLiquidityRegime = ({
+  stale,
+  btcDominanceChange24hPct,
+  altMarketCapChange24hPct,
+  altVolumeChange24hPct
+}) => {
+  if (stale) return "unknown";
+  if (altMarketCapChange24hPct != null && altMarketCapChange24hPct <= -0.03 || altVolumeChange24hPct != null && altVolumeChange24hPct <= -0.15) {
+    return "risk_off";
+  }
+  if (btcDominanceChange24hPct != null && btcDominanceChange24hPct >= 0.25) {
+    return "btc_favored";
+  }
+  if (btcDominanceChange24hPct != null && btcDominanceChange24hPct <= -0.25 && (altMarketCapChange24hPct == null || altMarketCapChange24hPct >= 0)) {
+    return "alt_friendly";
+  }
+  return "neutral";
+};
+var toReferenceLiquidityRegime = ({
+  stale,
+  ethBtcMarketCapRatioChange24hPct,
+  ethVsBtcVolumeRatio
+}) => {
+  if (stale) return "unknown";
+  if (ethVsBtcVolumeRatio != null && ethVsBtcVolumeRatio < 0.15) return "thin";
+  if (ethBtcMarketCapRatioChange24hPct != null && ethBtcMarketCapRatioChange24hPct >= 0.01) {
+    return "eth_led";
+  }
+  if (ethBtcMarketCapRatioChange24hPct != null && ethBtcMarketCapRatioChange24hPct <= -0.01) {
+    return "btc_led";
+  }
+  return "balanced";
+};
+var toExchangeLiquidityRegime = ({
+  stale,
+  totalVolumeChange24hPct,
+  fallback
+}) => {
+  if (stale) return "unknown";
+  if (totalVolumeChange24hPct != null && totalVolumeChange24hPct >= 0.15) {
+    return "expanding";
+  }
+  if (totalVolumeChange24hPct != null && totalVolumeChange24hPct <= -0.15) {
+    return "contracting";
+  }
+  return fallback;
+};
+var toIndexRegime = ({
+  stale,
+  cmc100Change24hPct,
+  cmc20Change24hPct,
+  cmc20ToCmc100RatioChange24hPct
+}) => {
+  if (stale) return "unknown";
+  if (cmc100Change24hPct == null && cmc20Change24hPct == null) {
+    return "unknown";
+  }
+  if ((cmc100Change24hPct ?? 0) <= -0.02 && (cmc20Change24hPct ?? 0) <= -0.02) {
+    return "risk_off";
+  }
+  if ((cmc20ToCmc100RatioChange24hPct ?? 0) >= 5e-3) {
+    return "top20_led";
+  }
+  if ((cmc20ToCmc100RatioChange24hPct ?? 0) <= -5e-3) {
+    return "large_cap_led";
+  }
+  return "balanced";
+};
+var getCachedGlobalContext = ({
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${SOURCE_GLOBAL_DAILY}:${timestamp}:${maxAgeMs}`;
+  const cached = globalContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_marketContext2.getLatestMarketGlobalContext)({
+    source: SOURCE_GLOBAL_DAILY,
+    atMs: timestamp,
+    maxAgeMs,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  globalContextCache.set(key, promise);
+  void promise.catch(() => globalContextCache.delete(key));
+  return promise;
+};
+var getCachedReferenceContexts = ({
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${SOURCE_REFERENCE}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = referenceContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_marketContext2.getLatestMarketReferenceAssetContexts)({
+    source: SOURCE_REFERENCE,
+    symbols: ["BTCUSDT", "ETHUSDT"],
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  referenceContextCache.set(key, promise);
+  void promise.catch(() => referenceContextCache.delete(key));
+  return promise;
+};
+var getCachedExchangeLiquidityContext = ({
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${SOURCE_EXCHANGE_LIQUIDITY}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = exchangeLiquidityContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_marketContext2.getLatestMarketCmcExchangeLiquidityContext)({
+    source: SOURCE_EXCHANGE_LIQUIDITY,
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  exchangeLiquidityContextCache.set(key, promise);
+  void promise.catch(() => exchangeLiquidityContextCache.delete(key));
+  return promise;
+};
+var getCachedFearGreedContext = ({
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${SOURCE_FEAR_GREED}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = fearGreedContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_marketContext2.getLatestMarketCmcFearGreedContext)({
+    source: SOURCE_FEAR_GREED,
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  fearGreedContextCache.set(key, promise);
+  void promise.catch(() => fearGreedContextCache.delete(key));
+  return promise;
+};
+var getCachedIndexContexts = ({
+  timestamp,
+  maxAgeMs,
+  abortSignal
+}) => {
+  const key = `${SOURCE_INDEX}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = indexContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_marketContext2.getLatestMarketCmcIndexContexts)({
+    source: SOURCE_INDEX,
+    indexSlugs: ["cmc100", "cmc20"],
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  indexContextCache.set(key, promise);
+  void promise.catch(() => indexContextCache.delete(key));
+  return promise;
+};
+var isCoinMarketCapContextEnabled = (env) => parseEnabledFlag2(process.env.COINMARKETCAP_CONTEXT_ENABLED, env);
+var enrichSignalWithCoinMarketCapContext = async (params) => {
+  const {
+    signal,
+    env,
+    enabled = isCoinMarketCapContextEnabled(env),
+    maxAgeMs = resolveMaxAgeMs()
+  } = params;
+  if (signal.universe === "tradfi" || !enabled || coinMarketCapContextUnavailable || !hasBaseContext2(signal)) {
+    return false;
+  }
+  try {
+    const [
+      globalDailyRow,
+      dailyReferences,
+      previousDailyReferences,
+      exchangeLiquidityRow,
+      fearGreedRow,
+      indexRows
+    ] = await Promise.all([
+      getCachedGlobalContext({
+        timestamp: signal.timestamp,
+        maxAgeMs,
+        abortSignal: params.abortSignal
+      }),
+      getCachedReferenceContexts({
+        timestamp: signal.timestamp,
+        maxAgeMs,
+        abortSignal: params.abortSignal
+      }),
+      getCachedReferenceContexts({
+        timestamp: signal.timestamp - DAY_MS,
+        maxAgeMs: maxAgeMs + DAY_MS,
+        abortSignal: params.abortSignal
+      }),
+      getCachedExchangeLiquidityContext({
+        timestamp: signal.timestamp,
+        maxAgeMs,
+        abortSignal: params.abortSignal
+      }),
+      getCachedFearGreedContext({
+        timestamp: signal.timestamp,
+        maxAgeMs,
+        abortSignal: params.abortSignal
+      }),
+      getCachedIndexContexts({
+        timestamp: signal.timestamp,
+        maxAgeMs,
+        abortSignal: params.abortSignal
+      })
+    ]);
+    const globalRow = globalDailyRow;
+    const references = dailyReferences;
+    const previousReferences = previousDailyReferences;
+    if (!globalRow && !references.size && !exchangeLiquidityRow && !fearGreedRow && !indexRows.size) {
+      return false;
+    }
+    const btcRow = references.get("BTCUSDT") ?? null;
+    const ethRow = references.get("ETHUSDT") ?? null;
+    const previousBtcRow = previousReferences.get("BTCUSDT") ?? null;
+    const previousEthRow = previousReferences.get("ETHUSDT") ?? null;
+    const btcMarketCapUsd = toFiniteNumberOrNull2(btcRow?.marketCapUsd);
+    const ethMarketCapUsd = toFiniteNumberOrNull2(ethRow?.marketCapUsd);
+    const previousBtcMarketCapUsd = toFiniteNumberOrNull2(
+      previousBtcRow?.marketCapUsd
+    );
+    const previousEthMarketCapUsd = toFiniteNumberOrNull2(
+      previousEthRow?.marketCapUsd
+    );
+    const ethBtcMarketCapRatio = safeDivide(ethMarketCapUsd, btcMarketCapUsd);
+    const previousEthBtcMarketCapRatio = safeDivide(
+      previousEthMarketCapUsd,
+      previousBtcMarketCapUsd
+    );
+    const ethBtcMarketCapRatioChange24hPct = ethBtcMarketCapRatio != null && previousEthBtcMarketCapRatio != null && previousEthBtcMarketCapRatio > 0 ? (ethBtcMarketCapRatio - previousEthBtcMarketCapRatio) / previousEthBtcMarketCapRatio : null;
+    const btcVolumeUsd = toFiniteNumberOrNull2(btcRow?.volumeUsd);
+    const ethVolumeUsd = toFiniteNumberOrNull2(ethRow?.volumeUsd);
+    const referenceStale = btcRow?.stale === true || ethRow?.stale === true || !btcRow || !ethRow;
+    const btcDominanceChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.btcDominanceChange24hPct
+    );
+    const altMarketCapChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.altMarketCapChange24hPct
+    );
+    const altVolumeChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.altVolumeChange24hPct
+    );
+    const altLiquidityRegime = globalRow ? toAltLiquidityRegime({
+      stale: globalRow.stale,
+      btcDominanceChange24hPct,
+      altMarketCapChange24hPct,
+      altVolumeChange24hPct
+    }) : "unknown";
+    const exchangeLiquidityRegime = exchangeLiquidityRow ? toExchangeLiquidityRegime({
+      stale: exchangeLiquidityRow.stale,
+      totalVolumeChange24hPct: toFiniteNumberOrNull2(
+        exchangeLiquidityRow.totalVolumeChange24hPct
+      ),
+      fallback: exchangeLiquidityRow.liquidityRegime ?? "unknown"
+    }) : "unknown";
+    const cmc100Row = indexRows.get("cmc100") ?? null;
+    const cmc20Row = indexRows.get("cmc20") ?? null;
+    const cmc100Value = toFiniteNumberOrNull2(cmc100Row?.value);
+    const cmc20Value = toFiniteNumberOrNull2(cmc20Row?.value);
+    const cmc100Change24hPct = toFiniteNumberOrNull2(
+      cmc100Row?.valueChange24hPct
+    );
+    const cmc20Change24hPct = toFiniteNumberOrNull2(cmc20Row?.valueChange24hPct);
+    const cmc20ToCmc100Ratio = safeDivide(cmc20Value, cmc100Value);
+    const cmc20ToCmc100RatioChange24hPct = cmc20Change24hPct != null && cmc100Change24hPct != null ? (1 + cmc20Change24hPct) / (1 + cmc100Change24hPct) - 1 : null;
+    const indexStale = cmc100Row?.stale === true || cmc20Row?.stale === true || !cmc100Row || !cmc20Row;
+    const indexRegime = toIndexRegime({
+      stale: indexStale,
+      cmc100Change24hPct,
+      cmc20Change24hPct,
+      cmc20ToCmc100RatioChange24hPct
+    });
+    const baseContext = signal.additionalIndicators.baseContext;
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators,
+      baseContext: {
+        ...baseContext,
+        relative: {
+          ...baseContext.relative,
+          ...globalRow ? {
+            cmcGlobal: {
+              source: globalRow.source,
+              interval: "1d",
+              asOfTs: globalRow.ts.getTime(),
+              ageMs: globalRow.ageMs,
+              stale: globalRow.stale,
+              totalMarketCapUsd: toFiniteNumberOrNull2(
+                globalRow.totalMarketCapUsd
+              ),
+              totalVolumeUsd: toFiniteNumberOrNull2(
+                globalRow.totalVolumeUsd
+              ),
+              totalVolumeReportedUsd: toFiniteNumberOrNull2(
+                globalRow.totalVolumeReportedUsd
+              ),
+              altMarketCapUsd: toFiniteNumberOrNull2(
+                globalRow.altMarketCapUsd
+              ),
+              altVolumeUsd: toFiniteNumberOrNull2(globalRow.altVolumeUsd),
+              altVolumeReportedUsd: toFiniteNumberOrNull2(
+                globalRow.altVolumeReportedUsd
+              ),
+              btcDominancePct: toFiniteNumberOrNull2(
+                globalRow.btcDominancePct
+              ),
+              ethDominancePct: toFiniteNumberOrNull2(
+                globalRow.ethDominancePct
+              ),
+              btcDominanceChange24hPct,
+              ethDominanceChange24hPct: toFiniteNumberOrNull2(
+                globalRow.ethDominanceChange24hPct
+              ),
+              altMarketCapChange24hPct,
+              altVolumeChange24hPct,
+              activeCryptocurrencies: toFiniteNumberOrNull2(
+                globalRow.activeCryptocurrencies
+              ),
+              activeExchanges: toFiniteNumberOrNull2(
+                globalRow.activeExchanges
+              ),
+              activeMarketPairs: toFiniteNumberOrNull2(
+                globalRow.activeMarketPairs
+              ),
+              altLiquidityRegime
+            }
+          } : {},
+          ...btcRow || ethRow ? {
+            cmcReferenceAssets: {
+              source: SOURCE_REFERENCE,
+              interval: "1d",
+              asOfTs: Math.max(
+                btcRow?.ts.getTime() ?? 0,
+                ethRow?.ts.getTime() ?? 0
+              ),
+              ageMs: btcRow?.ageMs != null && ethRow?.ageMs != null ? Math.max(btcRow.ageMs, ethRow.ageMs) : btcRow?.ageMs ?? ethRow?.ageMs ?? null,
+              stale: referenceStale,
+              btcMarketCapUsd,
+              ethMarketCapUsd,
+              btcVolumeUsd,
+              ethVolumeUsd,
+              btcVolumeToMarketCap: safeDivide(
+                btcVolumeUsd,
+                btcMarketCapUsd
+              ),
+              ethVolumeToMarketCap: safeDivide(
+                ethVolumeUsd,
+                ethMarketCapUsd
+              ),
+              ethBtcMarketCapRatio,
+              ethBtcMarketCapRatioChange24hPct,
+              ethVsBtcVolumeRatio: safeDivide(ethVolumeUsd, btcVolumeUsd),
+              referenceLiquidityRegime: toReferenceLiquidityRegime({
+                stale: referenceStale,
+                ethBtcMarketCapRatioChange24hPct,
+                ethVsBtcVolumeRatio: safeDivide(ethVolumeUsd, btcVolumeUsd)
+              })
+            }
+          } : {},
+          ...exchangeLiquidityRow ? {
+            cmcExchangeLiquidity: {
+              source: SOURCE_EXCHANGE_LIQUIDITY,
+              interval: exchangeLiquidityRow.interval,
+              asOfTs: exchangeLiquidityRow.ts.getTime(),
+              ageMs: exchangeLiquidityRow.ageMs,
+              stale: exchangeLiquidityRow.stale,
+              exchangesCount: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.exchangesCount
+              ),
+              totalVolumeUsd: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.totalVolumeUsd
+              ),
+              totalVolumeChange24hPct: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.totalVolumeChange24hPct
+              ),
+              binanceVolumeUsd: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.binanceVolumeUsd
+              ),
+              binanceVolumeShare: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.binanceVolumeShare
+              ),
+              topExchangeVolumeShare: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.topExchangeVolumeShare
+              ),
+              liquidityRegime: exchangeLiquidityRegime
+            }
+          } : {},
+          ...fearGreedRow ? {
+            cmcFearGreed: {
+              source: SOURCE_FEAR_GREED,
+              interval: "1d",
+              asOfTs: fearGreedRow.ts.getTime(),
+              ageMs: fearGreedRow.ageMs,
+              stale: fearGreedRow.stale,
+              value: toFiniteNumberOrNull2(fearGreedRow.value),
+              valueChange24h: toFiniteNumberOrNull2(
+                fearGreedRow.valueChange24h
+              ),
+              valueChange7d: toFiniteNumberOrNull2(
+                fearGreedRow.valueChange7d
+              ),
+              classification: fearGreedRow.classification ?? "Unknown",
+              sentimentRegime: fearGreedRow.sentimentRegime ?? "unknown"
+            }
+          } : {},
+          ...cmc100Row || cmc20Row ? {
+            cmcIndexes: {
+              source: SOURCE_INDEX,
+              interval: "1d",
+              asOfTs: Math.max(
+                cmc100Row?.ts.getTime() ?? 0,
+                cmc20Row?.ts.getTime() ?? 0
+              ),
+              ageMs: cmc100Row?.ageMs != null && cmc20Row?.ageMs != null ? Math.max(cmc100Row.ageMs, cmc20Row.ageMs) : cmc100Row?.ageMs ?? cmc20Row?.ageMs ?? null,
+              stale: indexStale,
+              cmc100Value,
+              cmc100Change24hPct,
+              cmc100TopConstituentSymbol: cmc100Row?.topConstituentSymbol ?? null,
+              cmc100TopConstituentWeightPct: toFiniteNumberOrNull2(
+                cmc100Row?.topConstituentWeightPct
+              ),
+              cmc20Value,
+              cmc20Change24hPct,
+              cmc20TopConstituentSymbol: cmc20Row?.topConstituentSymbol ?? null,
+              cmc20TopConstituentWeightPct: toFiniteNumberOrNull2(
+                cmc20Row?.topConstituentWeightPct
+              ),
+              cmc20ToCmc100Ratio,
+              cmc20ToCmc100RatioChange24hPct,
+              indexRegime
+            }
+          } : {}
+        }
+      }
+    };
+    (0, import_strategies2.refreshSignalBaseContextGateFeatures)(signal);
+    return true;
+  } catch (error) {
+    if (isMarketContextCancellationError(error, params.abortSignal)) {
+      throw error;
+    }
+    coinMarketCapContextUnavailable = true;
+    import_logger4.logger.warn(
+      "CoinMarketCap context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyHelpers/derivativesContext.ts
+var import_indicators = require("@tradejs/core/indicators");
+var import_data = require("@tradejs/core/data");
+var import_strategies3 = require("@tradejs/core/strategies");
+var import_constants2 = require("@tradejs/core/constants");
+var import_derivatives = require("@tradejs/infra/timescale/derivatives");
+var import_logger5 = require("@tradejs/infra/logger");
+var STORED_INTERVALS = ["15m", "1h"];
+var CONTEXT_INTERVALS = ["15m", "1h"];
+var DEFAULT_LOOKBACK_HOURS = 48;
+var PRIMARY_DERIVATIVES_REFERENCE_SYMBOL = import_constants2.DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[0];
+var SECONDARY_DERIVATIVES_REFERENCE_SYMBOL = import_constants2.DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[1];
+var derivativesContextUnavailable = false;
+var parseEnabledFlag3 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return true;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var parseBooleanFlag = (value, fallback = false) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+};
+var parseLookbackMs = () => {
+  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
+  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
+  return normalizedHours * 60 * 60 * 1e3;
+};
+var withHourlyFallbackRows = (rowsByInterval) => ({
+  "15m": rowsByInterval["15m"] ?? [],
+  "1h": (0, import_indicators.buildCoinalyzeHourlyRowsWithFallback)({
+    rows15m: rowsByInterval["15m"],
+    fallbackRows1h: rowsByInterval["1h"]
+  })
+});
+var getDerivativesContextReferenceSymbols = () => [
+  ...(0, import_constants2.resolveDerivativesContextReferenceSymbols)(
+    process.env.DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS
+  )
+];
+var normalizeSymbol = (symbol) => String(symbol || "").trim().toUpperCase();
+var getSignalPriceChangePct1h = (signal) => {
+  const baseContext = signal.additionalIndicators?.baseContext;
+  if (!baseContext || typeof baseContext !== "object" || Array.isArray(baseContext)) {
+    return null;
+  }
+  const raw = typeof baseContext.raw === "object" && baseContext.raw && !Array.isArray(baseContext.raw) ? baseContext.raw : null;
+  const price = raw && typeof raw.price === "object" && raw.price && !Array.isArray(raw.price) ? raw.price : null;
+  const value = price?.price1hPct;
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var resolvePrimaryReferenceSymbol2 = () => PRIMARY_DERIVATIVES_REFERENCE_SYMBOL;
+var resolveSecondaryReferenceSymbol = () => SECONDARY_DERIVATIVES_REFERENCE_SYMBOL;
+var getPrimaryIntervalContext = (context) => context?.intervals["15m"] ?? context?.intervals["1h"] ?? null;
+var hasDerivativesSymbolData = (context) => Object.keys(context.intervals).length > 0 && !context.summary.riskFlags.includes("missing_derivatives");
+var toFiniteNumberOrNull3 = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var roundNullable = (value, digits = 4) => {
+  if (value == null || !Number.isFinite(value)) return null;
+  const multiplier = 10 ** digits;
+  return Math.round(value * multiplier) / multiplier;
+};
+var deltaNullable = (targetValue, referenceValue) => {
+  const target = toFiniteNumberOrNull3(targetValue);
+  const reference = toFiniteNumberOrNull3(referenceValue);
+  return target == null || reference == null ? null : roundNullable(target - reference);
+};
+var buildTargetDerivedContext = (params) => {
+  const { targetContext, primaryReferenceContext } = params;
+  const targetPrimary = getPrimaryIntervalContext(targetContext);
+  const referencePrimary = getPrimaryIntervalContext(primaryReferenceContext);
+  const targetDirectionAligned = targetContext.summary.directionAligned;
+  const referenceDirectionAligned = primaryReferenceContext?.summary.directionAligned ?? null;
+  return {
+    available: hasDerivativesSymbolData(targetContext),
+    stale: targetContext.summary.riskFlags.includes("stale_derivatives") || targetPrimary?.stale === true ? true : targetPrimary == null ? null : false,
+    sourceSymbol: targetContext.symbol,
+    referenceSymbol: primaryReferenceContext?.symbol ?? null,
+    directionAligned: targetDirectionAligned,
+    referenceDirectionAligned,
+    pressure: targetContext.summary.pressure ?? null,
+    referencePressure: primaryReferenceContext?.summary.pressure ?? null,
+    riskFlags: targetContext.summary.riskFlags,
+    oiChangePct1h: targetPrimary?.oiChangePct1h ?? null,
+    oiAcceleration: targetContext.summary.oiAcceleration ?? null,
+    fundingRate: targetPrimary?.fundingRate ?? null,
+    fundingZScore: targetPrimary?.fundingZScore ?? null,
+    fundingChange1h: targetContext.summary.fundingChange1h ?? null,
+    liqSpikeRatio: targetPrimary?.liqSpikeRatio ?? null,
+    liqImbalance: targetPrimary?.liqImbalance ?? null,
+    targetVsPrimaryOiChangePct1hDelta: deltaNullable(
+      targetPrimary?.oiChangePct1h,
+      referencePrimary?.oiChangePct1h
+    ),
+    targetVsPrimaryFundingZScoreDelta: deltaNullable(
+      targetPrimary?.fundingZScore,
+      referencePrimary?.fundingZScore
+    ),
+    targetReferenceConflict: targetDirectionAligned == null || referenceDirectionAligned == null ? null : targetDirectionAligned !== referenceDirectionAligned
+  };
+};
+var buildReferenceDerivativesContext = (params) => {
+  const {
+    targetSymbol,
+    primaryReferenceSymbol,
+    secondaryReferenceSymbol,
+    referenceSymbols,
+    referenceContexts,
+    targetContext
+  } = params;
+  const primaryContext = referenceContexts[primaryReferenceSymbol] ?? referenceContexts[referenceSymbols[0]];
+  if (!primaryContext) {
+    throw new Error("No derivatives reference contexts built");
+  }
+  const referenceSymbolsMetadata = [
+    .../* @__PURE__ */ new Set([
+      primaryReferenceSymbol,
+      secondaryReferenceSymbol,
+      ...referenceSymbols,
+      ...Object.keys(referenceContexts)
+    ])
+  ];
+  const targetDerived = targetContext && hasDerivativesSymbolData(targetContext) ? buildTargetDerivedContext({
+    targetContext,
+    primaryReferenceContext: primaryContext
+  }) : void 0;
+  return {
+    ...primaryContext,
+    targetSymbol,
+    primaryReferenceSymbol: primaryContext.symbol,
+    secondaryReferenceSymbol: referenceContexts[secondaryReferenceSymbol]?.symbol ?? secondaryReferenceSymbol,
+    referenceSymbols: referenceSymbolsMetadata,
+    referenceContexts,
+    ...targetContext && targetDerived ? {
+      targetContext,
+      targetDerived
+    } : {}
+  };
+};
+var isDerivativesContextEnabled = (env) => parseEnabledFlag3(process.env.DERIVATIVES_CONTEXT_ENABLED, env);
+var isDerivativesTargetContextEnabled = () => parseBooleanFlag(process.env.DERIVATIVES_CONTEXT_TARGET_ENABLED, false);
+var enrichSignalWithDerivativesContext = async (params) => {
+  const { signal, env, enabled = isDerivativesContextEnabled(env) } = params;
+  if (signal.universe === "tradfi" || !enabled || derivativesContextUnavailable) {
+    return false;
+  }
+  try {
+    const referenceSymbols = getDerivativesContextReferenceSymbols();
+    const targetSymbol = normalizeSymbol(signal.symbol);
+    const lookbackMs = parseLookbackMs();
+    const decisionTimeMs = signal.timestamp + (0, import_data.intervalToMs)(signal.interval);
+    const derivativesEndMs = (0, import_indicators.getLastClosedDerivativesBarStartMs)(
+      decisionTimeMs,
+      "15m"
+    );
+    const contexts = await Promise.all(
+      referenceSymbols.map(async (symbol) => {
+        const rowsByInterval = await (0, import_derivatives.getDerivativesWindow)({
+          symbol,
+          intervals: STORED_INTERVALS,
+          endMs: derivativesEndMs,
+          lookbackMs,
+          ...params.abortSignal ? { signal: params.abortSignal } : {}
+        });
+        return [
+          symbol,
+          (0, import_indicators.buildDerivativesContext)({
+            symbol,
+            direction: signal.direction,
+            timestamp: derivativesEndMs,
+            rowsByInterval: withHourlyFallbackRows(rowsByInterval),
+            priceChangePct1h: getSignalPriceChangePct1h(signal),
+            intervals: CONTEXT_INTERVALS
+          })
+        ];
+      })
+    );
+    const referenceContexts = Object.fromEntries(contexts);
+    const primaryReferenceSymbol = resolvePrimaryReferenceSymbol2();
+    const secondaryReferenceSymbol = resolveSecondaryReferenceSymbol();
+    const targetContextEnabled = isDerivativesTargetContextEnabled();
+    const referenceTargetContext = targetContextEnabled && targetSymbol !== primaryReferenceSymbol ? referenceContexts[targetSymbol] : void 0;
+    const shouldFetchTargetContext = targetContextEnabled && targetSymbol.length > 0 && !referenceSymbols.some(
+      (referenceSymbol) => referenceSymbol === targetSymbol
+    );
+    const fetchedTargetContext = shouldFetchTargetContext ? await (async () => {
+      const rowsByInterval = await (0, import_derivatives.getDerivativesWindow)({
+        symbol: targetSymbol,
+        intervals: STORED_INTERVALS,
+        endMs: derivativesEndMs,
+        lookbackMs,
+        ...params.abortSignal ? { signal: params.abortSignal } : {}
+      });
+      const context = (0, import_indicators.buildDerivativesContext)({
+        symbol: targetSymbol,
+        direction: signal.direction,
+        timestamp: derivativesEndMs,
+        rowsByInterval: withHourlyFallbackRows(rowsByInterval),
+        priceChangePct1h: getSignalPriceChangePct1h(signal),
+        intervals: CONTEXT_INTERVALS
+      });
+      return hasDerivativesSymbolData(context) ? context : void 0;
+    })() : void 0;
+    const targetContext = referenceTargetContext && hasDerivativesSymbolData(referenceTargetContext) ? referenceTargetContext : fetchedTargetContext;
+    const derivativesContext = buildReferenceDerivativesContext({
+      targetSymbol: targetSymbol || signal.symbol,
+      primaryReferenceSymbol,
+      secondaryReferenceSymbol,
+      referenceSymbols,
+      referenceContexts,
+      targetContext
+    });
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators ?? {},
+      baseContext: signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext) ? {
+        ...signal.additionalIndicators.baseContext,
+        derivatives: derivativesContext
+      } : signal.additionalIndicators?.baseContext
+    };
+    (0, import_strategies3.refreshSignalBaseContextGateFeatures)(signal);
+    return true;
+  } catch (error) {
+    if (isMarketContextCancellationError(error, params.abortSignal)) {
+      throw error;
+    }
+    derivativesContextUnavailable = true;
+    import_logger5.logger.warn(
+      "Derivatives context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyHelpers/hyperliquidWhaleContext.ts
+var import_data2 = require("@tradejs/core/data");
+var import_strategies4 = require("@tradejs/core/strategies");
+var import_hyperliquidWhales2 = require("@tradejs/infra/timescale/hyperliquidWhales");
+var import_logger6 = require("@tradejs/infra/logger");
+
+// src/hyperliquidWhaleUniverse.ts
+var import_node_crypto3 = require("crypto");
+
+// src/config/hyperliquidPerpUniverse.json
+var hyperliquidPerpUniverse_default = {
+  schemaVersion: 1,
+  updatedAt: "2026-08-04T11:46:43.476Z",
+  source: "hyperliquid_main_perp_day_notional_volume",
+  fingerprint: "58f7e024b19158dc",
+  size: 30,
+  symbols: [
+    "BTC",
+    "ETH",
+    "HYPE",
+    "SOL",
+    "ZEC",
+    "PUMP",
+    "XRP",
+    "CASHCAT",
+    "WLD",
+    "GRAM",
+    "UNI",
+    "ADA",
+    "LIT",
+    "ENA",
+    "NEAR",
+    "kPEPE",
+    "FARTCOIN",
+    "KAITO",
+    "AAVE",
+    "SUI",
+    "ONDO",
+    "AVAX",
+    "DOGE",
+    "VVV",
+    "BNB",
+    "ALGO",
+    "XMR",
+    "MEGA",
+    "LINK",
+    "TAO"
+  ]
+};
+
+// src/config/hyperliquidWhales.json
+var hyperliquidWhales_default = {
+  schemaVersion: 2,
+  updatedAt: "2026-08-04T15:10:21.316Z",
+  source: "hyperliquid_structural_fills_snapshot",
+  selection: {
+    calibrationFrom: "2026-07-28T00:00:00.000Z",
+    calibrationTo: "2026-08-04T00:00:00.000Z",
+    effectiveFrom: "2026-08-04T00:00:00.000Z",
+    candidateLimit: 400,
+    minimumAccountValueUsd: 5e5,
+    minimumActiveDays: 1,
+    maximumRawFillsPerDay: 20,
+    maximumDirectionalExecutionsPerDay: 10,
+    minimumMedianNotionalUsd: 0,
+    minimumMedianInterExecutionMinutes: 0,
+    minimumTop30NotionalShare: 1e-3,
+    minimumTurnoverToEquity: 0.05,
+    maximumTurnoverToEquity: 5,
+    score: "log1p(accountValue)*log1p(medianExecutionNotional)*log1p(max(1,medianInterExecutionMinutes))*sqrt(activeDays)*top30Share/sqrt(1+rawFillsPerDay)",
+    forbiddenSelectionMetrics: ["pnl", "roi", "winRate", "closedPnl"]
+  },
+  fingerprint: "77a6e9d41222efdb",
+  size: 100,
+  addresses: [
+    "0xacb66d1996501bcc82a0e7819c9e041599f5efbd",
+    "0x90dbb196cacf24bd212b377a0dd62eaad5e8151b",
+    "0xde5b8c8e713f7c29ec72c22a326d61e5ac76e402",
+    "0x22edc38749b59c31c9319eae7fc62143ac2fcc6c",
+    "0x4bc9a771cd2c96cb2a4501f2c049402b4e7e11b3",
+    "0x9a0825ca6c4c577a1202a8fae3b8f044c1d5711d",
+    "0xb6ca5d1ed0ca4bf8444c9dee2d068a9f4c5e2e92",
+    "0xc3610d02548cdb1a30ede87c5dc0d2ffe5b9b99f",
+    "0x48c6aaa647ad5197e85797f8eb95d7b9ce1ec5b6",
+    "0x8c1ab015da7e5319649afca4a551924f89eff883",
+    "0x64bddab5f13a99576fca6747f0aa205422c5f708",
+    "0x98785f2a43fe32f972476b86ed5a5cfaf5240f00",
+    "0x9836e286fbf4f71998827d4bd6ea3b470c26457e",
+    "0x8f8d2d2565bfb10608a7ce64b48e2aea7875a344",
+    "0xe6df4ed7a6ccb8426cbc87bdcdd3cc6d0e6c0690",
+    "0xab04d040dec929a204298d44701476968b238b69",
+    "0x870f718a84843abc3e22412a9b4dc2924466d448",
+    "0x12c206d3e2f0d0059420c54d33fe604ebbecc230",
+    "0x7d9e91a8a47eb553cbfd323e7633c0c213327124",
+    "0x2057d4f2b6ea957b63371980775b0a5505a438f0",
+    "0xead5b7d86c681c036c59cd00a0390541061c69f2",
+    "0x3005fade4c0df5e1cd187d7062da359416f0eb8e",
+    "0xe83b5e3644b50e802a25b34b38b91a061a0d3ca8",
+    "0x525232cb6ed5030d2b052b36bfc0baec96986ee3",
+    "0xa251520154ca342f0b1d702bf5a56f78c982405b",
+    "0xa9184bb57fd75c7c63e4c074d6319eceac6be53b",
+    "0xa20fb0c9e04063eec5be286e9269028d966646fa",
+    "0x169ba96d963e77a87dbe58922ecdcdd0f0cf3315",
+    "0x115849ce84370f25cadcf0d348510d73837e1aa5",
+    "0x37b81ab9e3ab04b9e3738e4891621205aaa31fd5",
+    "0x90f57d90a7dd3114312d4c31803ad5732baf5935",
+    "0xad227f63d34e7251c1d0ab65e64eeea07aee4e44",
+    "0xd38e2b0b3c85ae138532f9fe1a1d5f5455866b82",
+    "0xf5f4c3aa62a0f903a8529905031b1536d1cf16f8",
+    "0x75632aaf83120eae9b0618f8f50773ce347de2ad",
+    "0x3927af597c09774f91ef84bf765ded4109e9f8ea",
+    "0xf1863bd6d60a8f4b5f583ec54009af6a044877bf",
+    "0xe7b34f28c54f85533896f8827edc92edac28b17f",
+    "0x1cda20f9f6a23c209d54940af3ef63b96c9b2c31",
+    "0x9e55b0e43b7f7f3909af841d326b2dadfda9392e",
+    "0x610b8dd6b392d010c2b6ad8d121dfc09524cb613",
+    "0x1d639a688b78f3d7e57166e59d9a8886b1bfb5a5",
+    "0x34d3a17095ef7def39a489d63c7c916e673c9ca2",
+    "0x5d0bde4017530ed43370e332a5d30194941f73c6",
+    "0xaa7afc250041e2c56a06d3b7a5295bd01929e11b",
+    "0x325edd95bb016c36027ce3b9f7595af7094a9564",
+    "0x47f5a6397b79deaaca5c456503e7c1a49357b942",
+    "0xf5e7ffe523d0491709958490b4877e1d9de6c6f7",
+    "0x64702807a1f0f9888ea22b858099d7f481227b55",
+    "0xd08a4557671ca465e7bba41110a93148c90f9931",
+    "0x0423b4b2acb4f219ae4a270abd5dde2360e455bb",
+    "0x7b29f8c0ea709b96b72214b3de5d85c3d9570794",
+    "0xeb8ebad162a9ce4cb7e2325c92b960b9df63365c",
+    "0x939f95036d2e7b6d7419ec072bf9d967352204d2",
+    "0x2490aa2b48022e857d44e738911787c8e2296aed",
+    "0x7622f628135378f1b8d1876952de9bab80245f1c",
+    "0x9d677028e0e592d48fc8a8ddc910693301a4a450",
+    "0x85e410e4c535cb1709dbd36468f132037a5b2087",
+    "0xd6f52e2ab58a678eced4a4d1693757b0677631c8",
+    "0x24d8969e2bd6aabb6c4dfe042ef8b2cd8085217e",
+    "0xda51323fe9800c8365646ad5c7ade0dd17fdc167",
+    "0x53f8f390fd4f70941c5d160a964f6893c8dbceff",
+    "0x72dae3560e7f4c59a305e2e739d6bd6777f738b5",
+    "0x36f5e448c9cf0032551e58919cf4eabefcd742c1",
+    "0x5b43b7162694de766c164202df0f0c716e4292ab",
+    "0xae551d73161bac3315c5ade0e2d499a44ebe2236",
+    "0x4eca8d62e07b3f3e78a8ae8725d4666da324c5a8",
+    "0x40a632026febd007b0e4431a29170507f7aa3896",
+    "0xd453e91f692eb5437cf345e09545827576e3225d",
+    "0xbe2c69eb3d7b8ee35cbe3a28293472be31179d75",
+    "0xfdf891f2b214a4c9374d26595ec6d4080262e381",
+    "0xfd97600ac44b3c4e20ac1a5f23e3b18d10fa5912",
+    "0x98e073b579fd483eac8f10d5bd0b32c8c3bbd7e0",
+    "0xb56f19e917546a60d658110a611cf62a6877b517",
+    "0xbd334a55db91617545e8d1b09941e036ad8e4200",
+    "0x9f1920d0cbb63ed03376a1e09fd2851d601234c8",
+    "0xe9cef9fd872a03cedf9d3e6e90309782b3724ea6",
+    "0xa43682a1f129e4faf0152175cc03c44e4957e8cf",
+    "0x6fbb33de5f39c690d2decb95b9ab46ed0c83e3bc",
+    "0x81d4163289cf61a0eaaac4862cb88ef0f4215c29",
+    "0xd248d2f09bfbe04e67fc7fea08828d6ad6d95b6d",
+    "0x01ffcc7285866e5cee14c8e807cb2e8d5f61079f",
+    "0xc69ae428f6049e78d445f053d2c1df879c59b34c",
+    "0xaab4dfe6d735c4ac46217216fe883a39fbfe8284",
+    "0xe912cac1a6641004a8803687ee7699227fdb0550",
+    "0x5fdbf83c3d95d525704f61401db68cbec1b2a775",
+    "0xebd7c4b3677a4480fb5f69ac2f51c51d66a19990",
+    "0xe4d1fa7e6141f9131345117bdb8b5701bca67662",
+    "0x685feceec46dd4e5c9b5b726f5d7550fd0eda526",
+    "0x3ea8b09da72972e953541500721803a187526da6",
+    "0xdbe0780a5c5a0e3b345101bbc01ac2218196d6d5",
+    "0x18cd4597e06b7fe0a8cd33dda499121b3a145a8b",
+    "0xb8243756956e722bff5c763971b562ac551bfbd2",
+    "0xe0bf8c96795d2df0b61b3b17e7cfd7d3ba13d4be",
+    "0x218a65e21eddeece7a9df38c6bbdd89f692b7da2",
+    "0x53b63a30a688beb53b5dc7bd731c661d678c555c",
+    "0xfce053a5e461683454bf37ad66d20344c0e3f4c0",
+    "0x3e516cf3c9d4f29fae6c1324c2414dc872fc9c09",
+    "0xe5f1486dc84706d2509885fe6bbc46d21ba81286",
+    "0x38042d713af713f0275b00640a83654db91ea543"
+  ]
+};
+
+// src/hyperliquidWhaleUniverse.ts
+var fingerprint2 = (value) => (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
+var validateUnique = (values, label) => {
+  if (new Set(values).size !== values.length) {
+    throw new Error(`Hyperliquid ${label} snapshot contains duplicates`);
+  }
+};
+var validatePerpSnapshot = (value) => {
+  const symbols = value.symbols.map((symbol) => symbol.trim()).filter(Boolean);
+  validateUnique(symbols, "perp universe");
+  if (value.schemaVersion !== 1 || value.source !== "hyperliquid_main_perp_day_notional_volume" || value.size !== 30 || symbols.length !== 30 || value.fingerprint !== fingerprint2(symbols)) {
+    throw new Error("Invalid Hyperliquid perp universe snapshot");
+  }
+  return value;
+};
+var validateWhaleSnapshot = (value) => {
+  const addresses = value.addresses.map((address) => address.toLowerCase());
+  validateUnique(addresses, "whale registry");
+  if (value.schemaVersion !== 2 || value.source !== "hyperliquid_structural_fills_snapshot" || value.size !== 100 || addresses.length !== 100 || addresses.some((address) => !/^0x[0-9a-f]{40}$/.test(address)) || value.fingerprint !== fingerprint2(addresses)) {
+    throw new Error("Invalid Hyperliquid whale registry snapshot");
+  }
+  return value;
+};
+var perpSnapshot = validatePerpSnapshot(hyperliquidPerpUniverse_default);
+var whaleSnapshot = validateWhaleSnapshot(hyperliquidWhales_default);
+var perpSymbolSet = new Set(perpSnapshot.symbols);
+var whaleAddressSet = new Set(whaleSnapshot.addresses);
+var getHyperliquidPerpUniverseSnapshot = () => perpSnapshot;
+var getHyperliquidWhaleRegistrySnapshot = () => whaleSnapshot;
+var SIGNAL_TO_HYPERLIQUID_ALIASES = {
+  PEPE: "kPEPE",
+  "1000PEPE": "kPEPE",
+  PUMPFUN: "PUMP",
+  SHIB: "kSHIB",
+  BONK: "kBONK"
+};
+var resolveHyperliquidPerpFromSignalSymbol = (symbol) => {
+  const normalized = symbol.trim().toUpperCase().replace(/(?:USDT|USDC)$/, "");
+  const candidate = SIGNAL_TO_HYPERLIQUID_ALIASES[normalized] ?? normalized;
+  return perpSymbolSet.has(candidate) ? candidate : null;
+};
+
+// src/strategyHelpers/hyperliquidWhaleContext.ts
+var MAX_CACHE_ENTRIES = 2048;
+var MAX_COVERAGE_SERIES_CACHE_ENTRIES = 20;
+var MAX_FLOW_SERIES_CACHE_ENTRIES = 64;
+var SERIES_CHUNK_MS = 90 * 24 * 60 * 6e4;
+var MAX_SERIES_LOOKBACK_MS = 60 * 6e4;
+var DEFAULT_MIN_COVERAGE_PCT = 0.8;
+var INTERVAL_MS = {
+  "1m": 6e4,
+  "5m": 5 * 6e4,
+  "15m": 15 * 6e4,
+  "1h": 60 * 6e4
+};
+var DEFAULT_MAX_AGE_BY_INTERVAL2 = {
+  "1m": 2 * 6e4,
+  "5m": 10 * 6e4,
+  "15m": 30 * 6e4,
+  "1h": 2 * 60 * 6e4
+};
+var hyperliquidWhaleContextUnavailable = false;
+var contextCache = /* @__PURE__ */ new Map();
+var coverageSeriesCache = /* @__PURE__ */ new Map();
+var flowSeriesCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag4 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return env !== "TEST";
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var getMinimumCoveragePct = () => {
+  const parsed = Number(process.env.HYPERLIQUID_WHALE_MIN_COVERAGE_PCT);
+  return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : DEFAULT_MIN_COVERAGE_PCT;
+};
+var signalIntervalToMarketInterval2 = (value) => {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "5" || normalized === "5m") return "5m";
+  if (normalized === "60" || normalized === "1h") return "1h";
+  return "15m";
+};
+var hasBaseContext3 = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var setBoundedCache = (key, value) => {
+  if (contextCache.size >= MAX_CACHE_ENTRIES) {
+    const oldestKey = contextCache.keys().next().value;
+    if (oldestKey != null) contextCache.delete(oldestKey);
+  }
+  contextCache.set(key, value);
+  void value.catch(() => contextCache.delete(key));
+};
+var setBoundedSeriesCache = (cache, maxEntries, key, value) => {
+  if (cache.size >= maxEntries) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey != null) cache.delete(oldestKey);
+  }
+  cache.set(key, value);
+  void value.catch(() => cache.delete(key));
+};
+var uniqueAddressCount = (rows, field) => {
+  const addresses = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const address of row[field]) addresses.add(address);
+  }
+  return addresses.size;
+};
+var sumFlowField = (rows, field) => rows.reduce((sum, row) => sum + row[field], 0);
+var sliceSeriesWindow = (rows, fromMs, toMs) => {
+  const lowerBound = (timestamp) => {
+    let low = 0;
+    let high = rows.length;
+    while (low < high) {
+      const middle = low + Math.floor((high - low) / 2);
+      if (rows[middle].ts.getTime() < timestamp) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  };
+  return rows.slice(lowerBound(fromMs), lowerBound(toMs));
+};
+var aggregateHyperliquidWhaleFlowSeries = (params) => {
+  const intervalMs = INTERVAL_MS[params.interval];
+  const windowStartMs = params.decisionTimeMs - intervalMs;
+  const coverageRows = sliceSeriesWindow(
+    params.coverageRows,
+    windowStartMs,
+    params.decisionTimeMs
+  );
+  const expectedBuckets = Math.ceil(intervalMs / 6e4);
+  if (coverageRows.length !== expectedBuckets || coverageRows.some((row) => row.coveredWhales <= 0)) {
+    return null;
+  }
+  const flowRows = sliceSeriesWindow(
+    params.flowRows,
+    windowStartMs,
+    params.decisionTimeMs
+  );
+  const asOfTs = new Date(
+    Math.max(...coverageRows.map((row) => row.ts.getTime()))
+  );
+  const coveredWhales = Math.min(
+    ...coverageRows.map((row) => row.coveredWhales)
+  );
+  const expectedWhales = Math.max(
+    ...coverageRows.map((row) => row.expectedWhales)
+  );
+  const coveragePct = Math.min(...coverageRows.map((row) => row.coveragePct));
+  const trades = sumFlowField(flowRows, "trades");
+  const whaleSides = sumFlowField(flowRows, "whaleSides");
+  const buyNotionalUsd = sumFlowField(flowRows, "buyNotionalUsd");
+  const sellNotionalUsd = sumFlowField(flowRows, "sellNotionalUsd");
+  const positionAwareWhaleSides = sumFlowField(
+    flowRows,
+    "positionAwareWhaleSides"
+  );
+  const longEntryNotionalUsd = sumFlowField(flowRows, "longEntryNotionalUsd");
+  const shortEntryNotionalUsd = sumFlowField(flowRows, "shortEntryNotionalUsd");
+  const longExitNotionalUsd = sumFlowField(flowRows, "longExitNotionalUsd");
+  const shortExitNotionalUsd = sumFlowField(flowRows, "shortExitNotionalUsd");
+  const totalNotionalUsd = buyNotionalUsd + sellNotionalUsd;
+  const totalEntryNotionalUsd = longEntryNotionalUsd + shortEntryNotionalUsd;
+  const ageMs = params.decisionTimeMs - (asOfTs.getTime() + 6e4);
+  return {
+    symbol: params.symbol,
+    interval: params.interval,
+    asOfTs,
+    windowEndTs: new Date(params.decisionTimeMs),
+    trades,
+    whaleSides,
+    uniqueWhales: uniqueAddressCount(flowRows, "whaleAddresses"),
+    coveredWhales,
+    expectedWhales,
+    coveragePct,
+    buyNotionalUsd,
+    sellNotionalUsd,
+    netNotionalUsd: buyNotionalUsd - sellNotionalUsd,
+    buySharePct: totalNotionalUsd > 0 ? buyNotionalUsd / totalNotionalUsd : null,
+    positionAwareWhaleSides,
+    positionAwarePct: whaleSides > 0 ? positionAwareWhaleSides / whaleSides : 0,
+    longEntryWhales: uniqueAddressCount(flowRows, "longEntryWhaleAddresses"),
+    shortEntryWhales: uniqueAddressCount(flowRows, "shortEntryWhaleAddresses"),
+    longExitWhales: uniqueAddressCount(flowRows, "longExitWhaleAddresses"),
+    shortExitWhales: uniqueAddressCount(flowRows, "shortExitWhaleAddresses"),
+    longEntryNotionalUsd,
+    shortEntryNotionalUsd,
+    longExitNotionalUsd,
+    shortExitNotionalUsd,
+    entryNetNotionalUsd: longEntryNotionalUsd - shortEntryNotionalUsd,
+    entryLongSharePct: totalEntryNotionalUsd > 0 ? longEntryNotionalUsd / totalEntryNotionalUsd : null,
+    universeFingerprint: params.universeFingerprint,
+    whaleRegistryFingerprint: params.whaleRegistryFingerprint,
+    source: positionAwareWhaleSides > 0 ? "hyperliquid_user_fills" : null,
+    ageMs,
+    stale: ageMs < 0 || (params.maxAgeMs != null && Number.isFinite(params.maxAgeMs) ? ageMs > params.maxAgeMs : false)
+  };
+};
+var loadHyperliquidWhaleFlowAggregateFromSeries = async (params) => {
+  const chunkStartMs = Math.floor(params.decisionTimeMs / SERIES_CHUNK_MS) * SERIES_CHUNK_MS;
+  const fromMs = chunkStartMs - MAX_SERIES_LOOKBACK_MS;
+  const toMs = chunkStartMs + SERIES_CHUNK_MS;
+  const sharedKey = [
+    fromMs,
+    toMs,
+    params.universeFingerprint,
+    params.whaleRegistryFingerprint
+  ].join(":");
+  let pendingCoverage = coverageSeriesCache.get(sharedKey);
+  if (!pendingCoverage) {
+    pendingCoverage = (0, import_hyperliquidWhales2.getHyperliquidWhaleCoverageSeriesRows)({
+      fromMs,
+      toMs,
+      universeFingerprint: params.universeFingerprint,
+      whaleRegistryFingerprint: params.whaleRegistryFingerprint,
+      ...params.abortSignal ? { signal: params.abortSignal } : {}
+    });
+    setBoundedSeriesCache(
+      coverageSeriesCache,
+      MAX_COVERAGE_SERIES_CACHE_ENTRIES,
+      sharedKey,
+      pendingCoverage
+    );
+  }
+  const flowKey = `${params.symbol}:${sharedKey}`;
+  let pendingFlow = flowSeriesCache.get(flowKey);
+  if (!pendingFlow) {
+    pendingFlow = (0, import_hyperliquidWhales2.getHyperliquidWhaleFlowSeriesRows)({
+      symbol: params.symbol,
+      fromMs,
+      toMs,
+      universeFingerprint: params.universeFingerprint,
+      whaleRegistryFingerprint: params.whaleRegistryFingerprint,
+      ...params.abortSignal ? { signal: params.abortSignal } : {}
+    });
+    setBoundedSeriesCache(
+      flowSeriesCache,
+      MAX_FLOW_SERIES_CACHE_ENTRIES,
+      flowKey,
+      pendingFlow
+    );
+  }
+  const [coverageRows, flowRows] = await Promise.all([
+    pendingCoverage,
+    pendingFlow
+  ]);
+  return aggregateHyperliquidWhaleFlowSeries({
+    ...params,
+    coverageRows,
+    flowRows
+  });
+};
+var toBaseHyperliquidWhaleFlowContext = (row, minimumCoveragePct) => ({
+  source: row.positionAwareWhaleSides > 0 ? "hyperliquid_user_fills" : "hyperliquid_trades",
+  interval: row.interval,
+  asOfTs: row.asOfTs.getTime(),
+  windowEndTs: row.windowEndTs.getTime(),
+  ageMs: row.ageMs,
+  stale: row.stale,
+  symbol: row.symbol,
+  trades: row.trades,
+  whaleSides: row.whaleSides,
+  uniqueWhales: row.uniqueWhales,
+  coveredWhales: row.coveredWhales,
+  expectedWhales: row.expectedWhales,
+  coveragePct: row.coveragePct,
+  coverageSufficient: row.coveragePct >= minimumCoveragePct,
+  buyNotionalUsd: row.buyNotionalUsd,
+  sellNotionalUsd: row.sellNotionalUsd,
+  netNotionalUsd: row.netNotionalUsd,
+  buySharePct: row.buySharePct,
+  positionAwareWhaleSides: row.positionAwareWhaleSides,
+  positionAwarePct: row.positionAwarePct,
+  longEntryWhales: row.longEntryWhales,
+  shortEntryWhales: row.shortEntryWhales,
+  longExitWhales: row.longExitWhales,
+  shortExitWhales: row.shortExitWhales,
+  longEntryNotionalUsd: row.longEntryNotionalUsd,
+  shortEntryNotionalUsd: row.shortEntryNotionalUsd,
+  longExitNotionalUsd: row.longExitNotionalUsd,
+  shortExitNotionalUsd: row.shortExitNotionalUsd,
+  entryNetNotionalUsd: row.entryNetNotionalUsd,
+  entryLongSharePct: row.entryLongSharePct,
+  universeFingerprint: row.universeFingerprint,
+  whaleRegistryFingerprint: row.whaleRegistryFingerprint
+});
+var isHyperliquidWhaleContextEnabled = (env) => parseEnabledFlag4(process.env.HYPERLIQUID_WHALE_CONTEXT_ENABLED, env);
+var loadHyperliquidWhaleFlowContext = async (params) => {
+  if (!(params.enabled ?? isHyperliquidWhaleContextEnabled(params.env)) || hyperliquidWhaleContextUnavailable || params.interval == null) {
+    return null;
+  }
+  const symbol = resolveHyperliquidPerpFromSignalSymbol(params.symbol);
+  if (!symbol) return null;
+  const interval = params.marketInterval ?? signalIntervalToMarketInterval2(params.interval);
+  const decisionTimeMs = params.timestamp + (0, import_data2.intervalToMs)(params.interval);
+  const maxAgeMs = params.maxAgeMs ?? DEFAULT_MAX_AGE_BY_INTERVAL2[interval];
+  const universe = getHyperliquidPerpUniverseSnapshot();
+  const whales = getHyperliquidWhaleRegistrySnapshot();
+  const minimumCoveragePct = getMinimumCoveragePct();
+  const cacheKey = [
+    symbol,
+    interval,
+    decisionTimeMs,
+    maxAgeMs,
+    universe.fingerprint,
+    whales.fingerprint,
+    minimumCoveragePct
+  ].join(":");
+  try {
+    let row;
+    if (params.useSeriesCache) {
+      row = await loadHyperliquidWhaleFlowAggregateFromSeries({
+        symbol,
+        interval,
+        decisionTimeMs,
+        maxAgeMs,
+        universeFingerprint: universe.fingerprint,
+        whaleRegistryFingerprint: whales.fingerprint,
+        abortSignal: params.abortSignal
+      });
+    } else {
+      let pending = contextCache.get(cacheKey);
+      if (!pending) {
+        pending = (0, import_hyperliquidWhales2.getHyperliquidWhaleFlowAggregate)({
+          symbol,
+          interval,
+          decisionTimeMs,
+          maxAgeMs,
+          universeFingerprint: universe.fingerprint,
+          whaleRegistryFingerprint: whales.fingerprint,
+          ...params.abortSignal ? { signal: params.abortSignal } : {}
+        });
+        setBoundedCache(cacheKey, pending);
+      }
+      row = await pending;
+    }
+    if (!row) return null;
+    return toBaseHyperliquidWhaleFlowContext(row, minimumCoveragePct);
+  } catch (error) {
+    if (isMarketContextCancellationError(error, params.abortSignal)) {
+      throw error;
+    }
+    hyperliquidWhaleContextUnavailable = true;
+    import_logger6.logger.warn(
+      "Hyperliquid whale context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return null;
+  }
+};
+var enrichSignalWithHyperliquidWhaleContext = async (params) => {
+  const { signal, env } = params;
+  if (signal.universe === "tradfi" || signal.interval == null || !hasBaseContext3(signal)) {
+    return false;
+  }
+  const hyperliquidWhales = await loadHyperliquidWhaleFlowContext({
+    symbol: signal.symbol,
+    interval: signal.interval,
+    timestamp: signal.timestamp,
+    env,
+    enabled: params.enabled,
+    marketInterval: params.interval,
+    maxAgeMs: params.maxAgeMs,
+    abortSignal: params.abortSignal
+  });
+  if (!hyperliquidWhales) return false;
+  const baseContext = signal.additionalIndicators.baseContext;
+  signal.additionalIndicators = {
+    ...signal.additionalIndicators,
+    baseContext: {
+      ...baseContext,
+      participation: {
+        ...baseContext.participation,
+        hyperliquidWhales
+      }
+    }
+  };
+  (0, import_strategies4.refreshSignalBaseContextGateFeatures)(signal);
+  return true;
+};
+
+// src/strategyHelpers/marketContextStages.ts
+var STAGE_ENV_KEYS = {
+  binance: "BINANCE_MARKET_CONTEXT_STAGE_TIMEOUT_MS",
+  coinmarketcap: "COINMARKETCAP_CONTEXT_STAGE_TIMEOUT_MS",
+  derivatives: "DERIVATIVES_CONTEXT_STAGE_TIMEOUT_MS",
+  hyperliquidWhales: "HYPERLIQUID_WHALE_CONTEXT_STAGE_TIMEOUT_MS"
+};
+var parsePositiveInt = (value) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+var resolveMarketContextStageTimeoutMs = (stage) => parsePositiveInt(process.env[STAGE_ENV_KEYS[stage]]) ?? parsePositiveInt(process.env.MARKET_CONTEXT_STAGE_TIMEOUT_MS) ?? 35e3;
+var runMarketContextStage = async ({
+  stage,
+  parentSignal,
+  operation,
+  onStart,
+  onComplete
+}) => {
+  const controller = new AbortController();
+  const timeoutMs = resolveMarketContextStageTimeoutMs(stage);
+  const startedAt = Date.now();
+  const onParentAbort = () => controller.abort(parentSignal?.reason);
+  parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+  if (parentSignal?.aborted) onParentAbort();
+  onStart?.(stage);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    let available = false;
+    try {
+      available = await operation(controller.signal);
+    } catch (error) {
+      if (isMarketContextCancellationError(error)) {
+        controller.abort(error);
+      }
+      if (!controller.signal.aborted) throw error;
+    }
+    const status = controller.signal.aborted ? "timed_out" : available ? "available" : "absent";
+    const result = {
+      stage,
+      status,
+      elapsedMs: Date.now() - startedAt
+    };
+    if (status === "timed_out") {
+      import_logger7.logger.warn(
+        "Market context stage timed out: %s after %sms",
+        stage,
+        result.elapsedMs
+      );
+    }
+    onComplete?.(result);
+    return result;
+  } finally {
+    clearTimeout(timer);
+    parentSignal?.removeEventListener("abort", onParentAbort);
+  }
+};
+var enrichSignalWithMarketContextStages = async ({
+  signal,
+  env,
+  coinMarketCapEnabled,
+  includeHyperliquidWhales = true,
+  abortSignal,
+  onStageStart,
+  onStageComplete
+}) => {
+  const stages = [
+    {
+      stage: "binance",
+      operation: (stageSignal) => enrichSignalWithBinanceMarketContext({
+        signal,
+        env,
+        abortSignal: stageSignal
+      })
+    },
+    {
+      stage: "coinmarketcap",
+      operation: (stageSignal) => enrichSignalWithCoinMarketCapContext({
+        signal,
+        env,
+        enabled: coinMarketCapEnabled,
+        abortSignal: stageSignal
+      })
+    },
+    {
+      stage: "derivatives",
+      operation: (stageSignal) => enrichSignalWithDerivativesContext({
+        signal,
+        env,
+        abortSignal: stageSignal
+      })
+    }
+  ];
+  if (includeHyperliquidWhales) {
+    stages.push({
+      stage: "hyperliquidWhales",
+      operation: (stageSignal) => enrichSignalWithHyperliquidWhaleContext({
+        signal,
+        env,
+        abortSignal: stageSignal
+      })
+    });
+  }
+  const results = [];
+  for (const stage of stages) {
+    if (abortSignal?.aborted) break;
+    results.push(
+      await runMarketContextStage({
+        ...stage,
+        parentSignal: abortSignal,
+        onStart: onStageStart,
+        onComplete: onStageComplete
+      })
+    );
+  }
+  return results;
+};
+
+// 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 snapshot2 of snapshots) {
+    if (snapshot2.symbol !== signal.symbol || snapshot2.direction !== direction || snapshot2.strategy && snapshot2.strategy !== signal.strategy) {
+      continue;
+    }
+    const toleranceMs = Math.max(0, Number(snapshot2.toleranceMs ?? 0));
+    const diff = Math.abs(snapshot2.timestamp - signal.timestamp);
+    if (diff > toleranceMs || best && diff >= best.diff) {
+      continue;
+    }
+    best = {
+      diff,
+      analysis: snapshot2.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 = (0, import_ml2.buildMlTrainingRow)(
+      buildMlPayload({
+        signal,
+        context: {
+          strategyConfig: ml.strategyConfig,
+          strategyName: strategy,
+          symbol: signal.symbol
+        }
+      }),
+      null
+    );
+    const row = (0, import_ml2.trimMlTrainingRowWindows)(fullRow, 5);
+    const features = (0, import_ml2.buildMlFeatures)(row);
+    const mlResult = await (0, import_ml2.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) {
+    import_logger8.logger.error("AI analysis error: %s %s", symbol, formatAiError(err));
+  }
+  return void 0;
+};
+var toFiniteNumberOrNull4 = (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 = toFiniteNumberOrNull4(ticker?.timestamp);
+    const bid = toFiniteNumberOrNull4(ticker?.bidPrice);
+    const ask = toFiniteNumberOrNull4(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) {
+    import_logger8.logger.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 * import_constants3.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"));
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
+var resolveStrategyConfig = async ({
+  strategyName,
+  userName,
+  symbol,
+  baseConfig,
+  defaults,
+  runtimeConfigId,
+  runtimeConfigSnapshot
+}) => {
+  const mergeIfNotEmpty = (target, patch) => patch && !import_lodash.default.isEmpty(patch) ? {
+    ...target,
+    ...patch
+  } : target;
+  let config = {
+    ...defaults,
+    ...baseConfig
+  };
+  let isConfigFromBacktest = false;
+  if (config.ENV !== "BACKTEST") {
+    const userConfig = runtimeConfigSnapshot ? runtimeConfigSnapshot.userConfig : await (0, import_runtimeStrategyConfigs.getRuntimeStrategyConfig)(
+      userName,
+      strategyName,
+      runtimeConfigId
+    ) ?? {};
+    config = mergeIfNotEmpty(config, userConfig);
+    if (!runtimeConfigId || runtimeConfigId === "config") {
+      const symbolResultConfig = runtimeConfigSnapshot ? runtimeConfigSnapshot.symbolResultConfig : await (0, import_runtimeStrategyConfigs.getRuntimeStrategyResultConfig)(userName, strategyName, symbol);
+      if (symbolResultConfig && !import_lodash.default.isEmpty(symbolResultConfig)) {
+        config = mergeIfNotEmpty(
+          config,
+          symbolResultConfig
+        );
+        isConfigFromBacktest = true;
+      }
+    }
+  }
+  return { config, isConfigFromBacktest };
+};
+
+// src/strategy/runtimeBacktestDelay.ts
+var import_constants4 = require("@tradejs/core/constants");
+var import_data3 = require("@tradejs/core/data");
+var import_strategies5 = require("@tradejs/core/strategies");
+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 import_constants4.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 (0, import_data3.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 = (0, import_strategies5.resolveBacktestExecutionPrice)(
+    candle,
+    backtestPriceMode ?? "open"
+  );
+  const executionTimestamp = candle.timestamp;
+  const takeProfitPrice = decision.entryContext.prices.takeProfitPrice;
+  const stopLossPrice = decision.orderPlan.stopLossPrice;
+  const riskRatio = (0, import_strategies5.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,
+      (0, import_strategies5.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;
+};
+
+// src/strategy/runtimeEntryPolicy.ts
+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 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 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"
+  };
+};
+
+// src/strategy/runtimeHooks.ts
+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 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);
+
+// src/strategy/runtimeExecution.ts
+var import_logger9 = require("@tradejs/infra/logger");
+var import_types = require("@tradejs/types");
+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 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) {
+        import_logger9.logger.warn(
+          "[%s] blocked closePosition for untracked runtime position: %s",
+          strategyName ?? "unknown",
+          symbol
+        );
+        return "CLOSE_BLOCKED_BY_UNTRACKED_POSITION";
+      }
+      if (!strategyName || activeTrade.strategy !== strategyName) {
+        import_logger9.logger.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) {
+        import_logger9.logger.error(
+          "runtime close notification error: %s %s",
+          symbol,
+          notificationError
+        );
+      }
+    }
+  } catch (err) {
+    await onRuntimeError?.({
+      stage: "closePosition",
+      error: err,
+      decision,
+      market
+    });
+    import_logger9.logger.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
+    });
+    import_logger9.logger.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 === import_types.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
+      import_logger9.logger.warn("order warning: %s %s", symbol, err);
+    } else {
+      import_logger9.logger.error("order error: %s %s", symbol, err);
+    }
+    return signal ?? "ORDER_ERROR";
+  }
+  return signal ?? decision.code;
+};
+
+// src/strategyRuntime.ts
+var cloneWithPropertyDescriptors = (value) => Object.create(
+  Object.getPrototypeOf(value),
+  Object.getOwnPropertyDescriptors(value)
+);
+var createStrategyRuntime = ({
+  strategyName,
+  defaults,
+  createCore,
+  manifest: staticManifest,
+  detectorKey,
+  detectorNoSignalSkipReason,
+  resolveRegisteredManifest
+}) => {
+  const projectRoot = getTradejsProjectCwd();
+  const resolveManifest = (name) => {
+    if (!name) {
+      return void 0;
+    }
+    if (staticManifest?.name === name) {
+      return staticManifest;
+    }
+    return resolveRegisteredManifest?.(name);
+  };
+  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 ?? import_constants5.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 = (0, import_strategies6.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) {
+          import_logger10.logger.error(
+            "project hook onRuntimeError failed: %s %s",
+            strategyName,
+            hookError
+          );
+        }
+      }
+      const onRuntimeError = errorManifest?.hooks?.onRuntimeError;
+      if (!onRuntimeError) {
+        return;
+      }
+      try {
+        await onRuntimeError(errorParams);
+      } catch (hookError) {
+        import_logger10.logger.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) {
+        import_logger10.logger.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 = (0, import_strategies6.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 = (0, import_strategies6.createStrategyAPI)({
+      strategy: strategyName,
+      symbol,
+      interval: config.INTERVAL ?? "15",
+      env,
+      connector,
+      cachedData: data,
+      indicatorsState,
+      isConfigFromBacktest,
+      sharedReplayKey: strategySharedReplayKey,
+      getSharedReplayState: import_strategies6.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({
+      config,
+      data,
+      strategyApi,
+      indicatorsState
+    });
+    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 (!import_constants5.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/strategy/manifests.ts
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = /* @__PURE__ */ new Map();
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
+var toUniqueModules = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
+  return {
+    strategyModules: toUniqueModules(config.strategies),
+    indicatorModules: toUniqueModules(config.indicators)
+  };
+};
+var extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
+  }
+  const candidate = moduleExport;
+  if (Array.isArray(candidate[key])) {
+    return candidate[key];
+  }
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport[key])) {
+    return defaultExport[key];
+  }
+  return null;
+};
+var extractStrategyPluginDefinition = (moduleExport) => {
+  const strategyEntries = extractModuleEntries(
+    moduleExport,
+    "strategyEntries"
+  );
+  return strategyEntries ? { strategyEntries } : null;
+};
+var extractIndicatorPluginDefinition = (moduleExport) => {
+  const indicatorEntries = extractModuleEntries(
+    moduleExport,
+    "indicatorEntries"
+  );
+  return indicatorEntries ? { indicatorEntries } : null;
+};
+var registerEntries = (entries, source, state) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest?.name;
+    if (!strategyName) {
+      import_logger11.logger.warn("Skip strategy entry without name from %s", source);
+      continue;
+    }
+    if (state.strategyCreators.has(strategyName)) {
+      import_logger11.logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyCreators.set(
+      strategyName,
+      createStrategyRuntime({
+        strategyName,
+        defaults: entry.defaults,
+        createCore: entry.createCore,
+        manifest: entry.manifest,
+        detectorKey: entry.detectorKey,
+        detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+        resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
+      })
+    );
+  }
+};
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    (0, import_indicators2.resetIndicatorRegistryCache)(projectRoot);
+    state.pluginsLoadPromise = (async () => {
+      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+      const strategySet = new Set(strategyModules);
+      const indicatorSet = new Set(indicatorModules);
+      const pluginModuleNames = [
+        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+      ];
+      if (!pluginModuleNames.length) {
+        return;
+      }
+      for (const moduleName of pluginModuleNames) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importStrategyPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              import_logger11.logger.warn(
+                'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerEntries(
+                pluginDefinition.strategyEntries,
+                moduleName,
+                state
+              );
+            }
+          }
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              import_logger11.logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              (0, import_indicators2.registerIndicatorEntries)(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            import_logger11.logger.warn(
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
+              moduleName
+            );
+          }
+        } catch (error) {
+          import_logger11.logger.warn(
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
 
 // src/strategyAdapters/ai.ts
 var toRecord2 = (value) => {
@@ -1614,7 +6209,7 @@ var askAI = async (signal, options = {}) => {
       payload
     }
   );
-  await (0, import_redis.setData)(import_redis.redisKeys.analysis(symbol, signal.signalId), content);
+  await (0, import_redis2.setData)(import_redis2.redisKeys.analysis(symbol, signal.signalId), content);
   return content;
 };
 // Annotate the CommonJS export names for ESM import in node: