@tradejs/node 2.0.21 → 3.0.1

package/dist/chunk-VRXU4E4O.mjs

@@ -0,0 +1,1469 @@
+import {
+  getTradejsProjectCwd,
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-WS5DYEVZ.mjs";
+
+// src/ai.ts
+import {
+  DEFAULT_AI_RESPONSE_LANGUAGE,
+  getAiResponseLanguagePromptName,
+  normalizeAiResponseLanguage
+} from "@tradejs/core/aiLanguages";
+import { normalizeAiEndpoint } from "@tradejs/core/aiEndpoints";
+import { normalizeAiModel } from "@tradejs/core/aiModels";
+import { setData, redisKeys } from "@tradejs/infra/redis";
+import {
+  getUserSettings
+} from "@tradejs/infra/userSettings";
+
+// src/aiShared.ts
+var MAX_AI_SERIES_POINTS = 5;
+var COMPACT_INDICATORS_SNAPSHOT_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "tradejs.indicators.compactSnapshot"
+);
+var COMPACT_INDICATORS_SNAPSHOT_KEY = "__tradejsCompactIndicatorsSnapshot";
+var trimSeriesDeep = (value) => {
+  if (Array.isArray(value)) {
+    const trimmed = value.slice(-MAX_AI_SERIES_POINTS);
+    const isMatrix = trimmed.every((item) => Array.isArray(item));
+    if (isMatrix) {
+      return trimmed;
+    }
+    return trimmed.map(
+      (item) => item && typeof item === "object" ? trimSeriesDeep(item) : item
+    );
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [
+        key,
+        trimSeriesDeep(nested)
+      ])
+    );
+  }
+  return value;
+};
+var buildCompactAiIndicatorsSnapshot = (value) => {
+  const compactSnapshot = value && typeof value === "object" ? value[COMPACT_INDICATORS_SNAPSHOT_SYMBOL] ?? value[COMPACT_INDICATORS_SNAPSHOT_KEY] : void 0;
+  if (typeof compactSnapshot === "function") {
+    return compactSnapshot({ limit: MAX_AI_SERIES_POINTS });
+  }
+  return trimSeriesDeep(value);
+};
+
+// src/aiMarketContext.ts
+var toRecord = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+};
+var toFiniteNumber = (value) => {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var roundTo = (value, decimals) => {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+};
+var buildMissingSpreadContext = () => ({
+  source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+  indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+  available: false,
+  value: null,
+  zScore: null,
+  bps: null,
+  absBps: null,
+  bias: null,
+  severity: null
+});
+var buildSpreadContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const execution = toRecord(relative?.execution);
+  const spread = toFiniteNumber(execution?.venueSpread);
+  const zScore = toFiniteNumber(execution?.venueSpreadZScore);
+  if (spread == null) {
+    return buildMissingSpreadContext();
+  }
+  const value = roundTo(spread, 8);
+  const bps = roundTo(value * 1e4, 2);
+  const absBps = Math.abs(bps);
+  const bias = absBps < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
+  const severity = absBps >= 20 ? "wide" : absBps >= 5 ? "elevated" : "normal";
+  return {
+    source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    available: true,
+    value,
+    zScore,
+    bps,
+    absBps,
+    bias,
+    severity
+  };
+};
+var buildTrueDeltaContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const participation = toRecord(baseContext?.participation);
+  const delta = toRecord(participation?.delta);
+  const source = String(delta?.source ?? "");
+  const isTrueDeltaSource = source === "kline_taker_volume" || source === "agg_trades" || source === "trades";
+  if (!delta || !isTrueDeltaSource) {
+    return {
+      source: source || null,
+      available: false,
+      buyPressurePct: null,
+      buyVolume: null,
+      sellVolume: null,
+      netDelta: null,
+      deltaPct: null,
+      signedVolumeZScore: null
+    };
+  }
+  return {
+    source,
+    available: true,
+    buyPressurePct: toFiniteNumber(delta.buyPressurePct),
+    buyVolume: toFiniteNumber(delta.buyVolume),
+    sellVolume: toFiniteNumber(delta.sellVolume),
+    netDelta: toFiniteNumber(delta.netDelta),
+    deltaPct: toFiniteNumber(delta.deltaPct),
+    signedVolumeZScore: toFiniteNumber(delta.signedVolumeZScore)
+  };
+};
+var buildTradeFlowContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const participation = toRecord(baseContext?.participation);
+  const tradeFlow = toRecord(participation?.tradeFlow);
+  if (!tradeFlow) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      stale: null,
+      trades: null,
+      buyPressurePct: null,
+      netBaseDelta: null,
+      netQuoteDelta: null
+    };
+  }
+  return {
+    source: String(tradeFlow.source ?? ""),
+    available: true,
+    interval: String(tradeFlow.interval ?? ""),
+    stale: typeof tradeFlow.stale === "boolean" ? tradeFlow.stale : null,
+    trades: toFiniteNumber(tradeFlow.trades),
+    buyPressurePct: toFiniteNumber(tradeFlow.buyPressurePct),
+    netBaseDelta: toFiniteNumber(tradeFlow.netBaseDelta),
+    netQuoteDelta: toFiniteNumber(tradeFlow.netQuoteDelta)
+  };
+};
+var buildMarketBreadthContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const breadth = toRecord(relative?.marketBreadth);
+  if (!breadth) {
+    return {
+      source: null,
+      available: false,
+      universe: null,
+      interval: null,
+      stale: null,
+      symbolsCount: null,
+      advanceDeclineRatio: null,
+      pctAboveMa20: null,
+      pctAboveMa50: null,
+      equalWeightedReturn: null,
+      volumeWeightedReturn: null,
+      dispersion: null
+    };
+  }
+  return {
+    source: String(breadth.source ?? ""),
+    available: true,
+    universe: String(breadth.universe ?? ""),
+    interval: String(breadth.interval ?? ""),
+    stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
+    symbolsCount: toFiniteNumber(breadth.symbolsCount),
+    advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
+    pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
+    pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
+    equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
+    volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
+    dispersion: toFiniteNumber(breadth.dispersion)
+  };
+};
+var buildMarketBreadthsContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const breadths = toRecord(relative?.marketBreadths);
+  const build = (key) => {
+    const breadth = toRecord(breadths?.[key]);
+    if (!breadth) {
+      return {
+        source: null,
+        available: false,
+        universe: null,
+        interval: null,
+        stale: null,
+        symbolsCount: null,
+        advanceDeclineRatio: null,
+        pctAboveMa20: null,
+        pctAboveMa50: null,
+        equalWeightedReturn: null,
+        volumeWeightedReturn: null,
+        dispersion: null
+      };
+    }
+    return {
+      source: String(breadth.source ?? ""),
+      available: true,
+      universe: String(breadth.universe ?? ""),
+      interval: String(breadth.interval ?? ""),
+      stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
+      symbolsCount: toFiniteNumber(breadth.symbolsCount),
+      advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
+      pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
+      pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
+      equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
+      volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
+      dispersion: toFiniteNumber(breadth.dispersion)
+    };
+  };
+  return {
+    top5: build("top5"),
+    top10: build("top10"),
+    top30: build("top30"),
+    top50: build("top50"),
+    top100: build("top100")
+  };
+};
+var buildTargetVsBtcContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const targetVsBtc = toRecord(relative?.targetVsBtc);
+  if (!targetVsBtc) {
+    return {
+      source: null,
+      available: false,
+      ratioReturn1h: null,
+      ratioReturn4h: null,
+      ratioReturn24h: null,
+      alphaVsBtc1h: null,
+      alphaVsBtc4h: null,
+      alphaVsBtc24h: null,
+      betaToBtc20: null,
+      correlationToBtc20: null,
+      ratioTrend: null
+    };
+  }
+  return {
+    source: String(targetVsBtc.source ?? ""),
+    available: true,
+    ratioReturn1h: toFiniteNumber(targetVsBtc.ratioReturn1h),
+    ratioReturn4h: toFiniteNumber(targetVsBtc.ratioReturn4h),
+    ratioReturn24h: toFiniteNumber(targetVsBtc.ratioReturn24h),
+    alphaVsBtc1h: toFiniteNumber(targetVsBtc.alphaVsBtc1h),
+    alphaVsBtc4h: toFiniteNumber(targetVsBtc.alphaVsBtc4h),
+    alphaVsBtc24h: toFiniteNumber(targetVsBtc.alphaVsBtc24h),
+    betaToBtc20: toFiniteNumber(targetVsBtc.betaToBtc20),
+    correlationToBtc20: toFiniteNumber(targetVsBtc.correlationToBtc20),
+    ratioTrend: typeof targetVsBtc.ratioTrend === "string" ? targetVsBtc.ratioTrend : null
+  };
+};
+var buildBtcAltRegimeContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const btcAltRegime = toRecord(relative?.btcAltRegime);
+  if (!btcAltRegime) {
+    return {
+      source: null,
+      available: false,
+      universe: null,
+      interval: null,
+      stale: null,
+      regime: null,
+      btcReturn24h: null,
+      altBasketReturn24h: null,
+      btcVsAltReturn24h: null,
+      btcTurnoverShare24h: null,
+      btcTurnoverShareChange24h: null,
+      altVolToBtcVol24h: null,
+      altDispersion24h: null
+    };
+  }
+  return {
+    source: String(btcAltRegime.source ?? ""),
+    available: true,
+    universe: String(btcAltRegime.universe ?? ""),
+    interval: String(btcAltRegime.interval ?? ""),
+    stale: typeof btcAltRegime.stale === "boolean" ? btcAltRegime.stale : null,
+    regime: typeof btcAltRegime.regime === "string" ? btcAltRegime.regime : null,
+    btcReturn24h: toFiniteNumber(btcAltRegime.btcReturn24h),
+    altBasketReturn24h: toFiniteNumber(btcAltRegime.altBasketReturn24h),
+    btcVsAltReturn24h: toFiniteNumber(btcAltRegime.btcVsAltReturn24h),
+    btcTurnoverShare24h: toFiniteNumber(btcAltRegime.btcTurnoverShare24h),
+    btcTurnoverShareChange24h: toFiniteNumber(
+      btcAltRegime.btcTurnoverShareChange24h
+    ),
+    altVolToBtcVol24h: toFiniteNumber(btcAltRegime.altVolToBtcVol24h),
+    altDispersion24h: toFiniteNumber(btcAltRegime.altDispersion24h)
+  };
+};
+var buildCmcGlobalContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcGlobal = toRecord(relative?.cmcGlobal);
+  if (!cmcGlobal) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      totalMarketCapUsd: null,
+      totalVolumeUsd: null,
+      totalVolumeReportedUsd: null,
+      altMarketCapUsd: null,
+      altVolumeUsd: null,
+      altVolumeReportedUsd: null,
+      btcDominancePct: null,
+      ethDominancePct: null,
+      btcDominanceChange24hPct: null,
+      ethDominanceChange24hPct: null,
+      altMarketCapChange24hPct: null,
+      altVolumeChange24hPct: null,
+      activeCryptocurrencies: null,
+      activeExchanges: null,
+      activeMarketPairs: null,
+      altLiquidityRegime: null
+    };
+  }
+  return {
+    source: String(cmcGlobal.source ?? ""),
+    available: true,
+    interval: typeof cmcGlobal.interval === "string" ? cmcGlobal.interval : null,
+    asOfTs: toFiniteNumber(cmcGlobal.asOfTs),
+    stale: typeof cmcGlobal.stale === "boolean" ? cmcGlobal.stale : null,
+    totalMarketCapUsd: toFiniteNumber(cmcGlobal.totalMarketCapUsd),
+    totalVolumeUsd: toFiniteNumber(cmcGlobal.totalVolumeUsd),
+    totalVolumeReportedUsd: toFiniteNumber(cmcGlobal.totalVolumeReportedUsd),
+    altMarketCapUsd: toFiniteNumber(cmcGlobal.altMarketCapUsd),
+    altVolumeUsd: toFiniteNumber(cmcGlobal.altVolumeUsd),
+    altVolumeReportedUsd: toFiniteNumber(cmcGlobal.altVolumeReportedUsd),
+    btcDominancePct: toFiniteNumber(cmcGlobal.btcDominancePct),
+    ethDominancePct: toFiniteNumber(cmcGlobal.ethDominancePct),
+    btcDominanceChange24hPct: toFiniteNumber(
+      cmcGlobal.btcDominanceChange24hPct
+    ),
+    ethDominanceChange24hPct: toFiniteNumber(
+      cmcGlobal.ethDominanceChange24hPct
+    ),
+    altMarketCapChange24hPct: toFiniteNumber(
+      cmcGlobal.altMarketCapChange24hPct
+    ),
+    altVolumeChange24hPct: toFiniteNumber(cmcGlobal.altVolumeChange24hPct),
+    activeCryptocurrencies: toFiniteNumber(cmcGlobal.activeCryptocurrencies),
+    activeExchanges: toFiniteNumber(cmcGlobal.activeExchanges),
+    activeMarketPairs: toFiniteNumber(cmcGlobal.activeMarketPairs),
+    altLiquidityRegime: typeof cmcGlobal.altLiquidityRegime === "string" ? cmcGlobal.altLiquidityRegime : null
+  };
+};
+var buildCmcReferenceAssetsContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcReferenceAssets = toRecord(relative?.cmcReferenceAssets);
+  if (!cmcReferenceAssets) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      btcMarketCapUsd: null,
+      ethMarketCapUsd: null,
+      btcVolumeUsd: null,
+      ethVolumeUsd: null,
+      btcVolumeToMarketCap: null,
+      ethVolumeToMarketCap: null,
+      ethBtcMarketCapRatio: null,
+      ethBtcMarketCapRatioChange24hPct: null,
+      ethVsBtcVolumeRatio: null,
+      referenceLiquidityRegime: null
+    };
+  }
+  return {
+    source: String(cmcReferenceAssets.source ?? ""),
+    available: true,
+    interval: typeof cmcReferenceAssets.interval === "string" ? cmcReferenceAssets.interval : null,
+    asOfTs: toFiniteNumber(cmcReferenceAssets.asOfTs),
+    stale: typeof cmcReferenceAssets.stale === "boolean" ? cmcReferenceAssets.stale : null,
+    btcMarketCapUsd: toFiniteNumber(cmcReferenceAssets.btcMarketCapUsd),
+    ethMarketCapUsd: toFiniteNumber(cmcReferenceAssets.ethMarketCapUsd),
+    btcVolumeUsd: toFiniteNumber(cmcReferenceAssets.btcVolumeUsd),
+    ethVolumeUsd: toFiniteNumber(cmcReferenceAssets.ethVolumeUsd),
+    btcVolumeToMarketCap: toFiniteNumber(
+      cmcReferenceAssets.btcVolumeToMarketCap
+    ),
+    ethVolumeToMarketCap: toFiniteNumber(
+      cmcReferenceAssets.ethVolumeToMarketCap
+    ),
+    ethBtcMarketCapRatio: toFiniteNumber(
+      cmcReferenceAssets.ethBtcMarketCapRatio
+    ),
+    ethBtcMarketCapRatioChange24hPct: toFiniteNumber(
+      cmcReferenceAssets.ethBtcMarketCapRatioChange24hPct
+    ),
+    ethVsBtcVolumeRatio: toFiniteNumber(cmcReferenceAssets.ethVsBtcVolumeRatio),
+    referenceLiquidityRegime: typeof cmcReferenceAssets.referenceLiquidityRegime === "string" ? cmcReferenceAssets.referenceLiquidityRegime : null
+  };
+};
+var buildCmcExchangeLiquidityContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcExchangeLiquidity = toRecord(relative?.cmcExchangeLiquidity);
+  if (!cmcExchangeLiquidity) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      exchangesCount: null,
+      totalVolumeUsd: null,
+      totalVolumeChange24hPct: null,
+      binanceVolumeUsd: null,
+      binanceVolumeShare: null,
+      topExchangeVolumeShare: null,
+      liquidityRegime: null
+    };
+  }
+  return {
+    source: String(cmcExchangeLiquidity.source ?? ""),
+    available: true,
+    interval: typeof cmcExchangeLiquidity.interval === "string" ? cmcExchangeLiquidity.interval : null,
+    asOfTs: toFiniteNumber(cmcExchangeLiquidity.asOfTs),
+    stale: typeof cmcExchangeLiquidity.stale === "boolean" ? cmcExchangeLiquidity.stale : null,
+    exchangesCount: toFiniteNumber(cmcExchangeLiquidity.exchangesCount),
+    totalVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.totalVolumeUsd),
+    totalVolumeChange24hPct: toFiniteNumber(
+      cmcExchangeLiquidity.totalVolumeChange24hPct
+    ),
+    binanceVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeUsd),
+    binanceVolumeShare: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeShare),
+    topExchangeVolumeShare: toFiniteNumber(
+      cmcExchangeLiquidity.topExchangeVolumeShare
+    ),
+    liquidityRegime: typeof cmcExchangeLiquidity.liquidityRegime === "string" ? cmcExchangeLiquidity.liquidityRegime : null
+  };
+};
+var buildCmcFearGreedContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcFearGreed = toRecord(relative?.cmcFearGreed);
+  if (!cmcFearGreed) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      value: null,
+      valueChange24h: null,
+      valueChange7d: null,
+      classification: null,
+      sentimentRegime: null
+    };
+  }
+  return {
+    source: String(cmcFearGreed.source ?? ""),
+    available: true,
+    interval: typeof cmcFearGreed.interval === "string" ? cmcFearGreed.interval : null,
+    asOfTs: toFiniteNumber(cmcFearGreed.asOfTs),
+    stale: typeof cmcFearGreed.stale === "boolean" ? cmcFearGreed.stale : null,
+    value: toFiniteNumber(cmcFearGreed.value),
+    valueChange24h: toFiniteNumber(cmcFearGreed.valueChange24h),
+    valueChange7d: toFiniteNumber(cmcFearGreed.valueChange7d),
+    classification: typeof cmcFearGreed.classification === "string" ? cmcFearGreed.classification : null,
+    sentimentRegime: typeof cmcFearGreed.sentimentRegime === "string" ? cmcFearGreed.sentimentRegime : null
+  };
+};
+var buildCmcIndexesContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcIndexes = toRecord(relative?.cmcIndexes);
+  if (!cmcIndexes) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      cmc100Value: null,
+      cmc100Change24hPct: null,
+      cmc100TopConstituentSymbol: null,
+      cmc100TopConstituentWeightPct: null,
+      cmc20Value: null,
+      cmc20Change24hPct: null,
+      cmc20TopConstituentSymbol: null,
+      cmc20TopConstituentWeightPct: null,
+      cmc20ToCmc100Ratio: null,
+      cmc20ToCmc100RatioChange24hPct: null,
+      indexRegime: null
+    };
+  }
+  return {
+    source: String(cmcIndexes.source ?? ""),
+    available: true,
+    interval: typeof cmcIndexes.interval === "string" ? cmcIndexes.interval : null,
+    asOfTs: toFiniteNumber(cmcIndexes.asOfTs),
+    stale: typeof cmcIndexes.stale === "boolean" ? cmcIndexes.stale : null,
+    cmc100Value: toFiniteNumber(cmcIndexes.cmc100Value),
+    cmc100Change24hPct: toFiniteNumber(cmcIndexes.cmc100Change24hPct),
+    cmc100TopConstituentSymbol: typeof cmcIndexes.cmc100TopConstituentSymbol === "string" ? cmcIndexes.cmc100TopConstituentSymbol : null,
+    cmc100TopConstituentWeightPct: toFiniteNumber(
+      cmcIndexes.cmc100TopConstituentWeightPct
+    ),
+    cmc20Value: toFiniteNumber(cmcIndexes.cmc20Value),
+    cmc20Change24hPct: toFiniteNumber(cmcIndexes.cmc20Change24hPct),
+    cmc20TopConstituentSymbol: typeof cmcIndexes.cmc20TopConstituentSymbol === "string" ? cmcIndexes.cmc20TopConstituentSymbol : null,
+    cmc20TopConstituentWeightPct: toFiniteNumber(
+      cmcIndexes.cmc20TopConstituentWeightPct
+    ),
+    cmc20ToCmc100Ratio: toFiniteNumber(cmcIndexes.cmc20ToCmc100Ratio),
+    cmc20ToCmc100RatioChange24hPct: toFiniteNumber(
+      cmcIndexes.cmc20ToCmc100RatioChange24hPct
+    ),
+    indexRegime: typeof cmcIndexes.indexRegime === "string" ? cmcIndexes.indexRegime : null
+  };
+};
+var buildReferenceTradeFlowContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const refs = toRecord(relative?.referenceTradeFlow);
+  const primaryReferenceSymbol = typeof refs?.primaryReferenceSymbol === "string" ? refs.primaryReferenceSymbol : null;
+  const tradeFlowBySymbol = toRecord(refs?.tradeFlowBySymbol);
+  const primaryTradeFlow = primaryReferenceSymbol != null ? toRecord(tradeFlowBySymbol?.[primaryReferenceSymbol]) : null;
+  if (!refs) {
+    return {
+      source: null,
+      available: false,
+      primaryReferenceSymbol: null,
+      referenceSymbols: [],
+      primaryTradeFlowBuyPressurePct: null,
+      primaryTradeFlowStale: null
+    };
+  }
+  return {
+    source: String(refs.source ?? ""),
+    available: true,
+    primaryReferenceSymbol,
+    referenceSymbols: Array.isArray(refs.referenceSymbols) ? refs.referenceSymbols.map(String) : [],
+    primaryTradeFlowBuyPressurePct: toFiniteNumber(
+      primaryTradeFlow?.buyPressurePct
+    ),
+    primaryTradeFlowStale: typeof primaryTradeFlow?.stale === "boolean" ? primaryTradeFlow.stale : null
+  };
+};
+var buildAiMarketContext = (signal) => ({
+  execution: {
+    binanceCoinbaseSpread: buildSpreadContextFromSignal(signal)
+  },
+  participation: {
+    trueDelta: buildTrueDeltaContextFromSignal(signal),
+    tradeFlow: buildTradeFlowContextFromSignal(signal)
+  },
+  relative: {
+    marketBreadth: buildMarketBreadthContextFromSignal(signal),
+    marketBreadths: buildMarketBreadthsContextFromSignal(signal),
+    targetVsBtc: buildTargetVsBtcContextFromSignal(signal),
+    btcAltRegime: buildBtcAltRegimeContextFromSignal(signal),
+    cmcGlobal: buildCmcGlobalContextFromSignal(signal),
+    cmcReferenceAssets: buildCmcReferenceAssetsContextFromSignal(signal),
+    cmcExchangeLiquidity: buildCmcExchangeLiquidityContextFromSignal(signal),
+    cmcFearGreed: buildCmcFearGreedContextFromSignal(signal),
+    cmcIndexes: buildCmcIndexesContextFromSignal(signal),
+    referenceTradeFlow: buildReferenceTradeFlowContextFromSignal(signal)
+  }
+});
+
+// src/strategy/manifests.ts
+import {
+  registerIndicatorEntries,
+  resetIndicatorRegistryCache
+} from "@tradejs/core/indicators";
+import { logger } from "@tradejs/infra/logger";
+var SHARED_STRATEGY_REGISTRY_KEY = "__tradejsNodeSharedStrategyRegistryV1__";
+var sharedRegistryScope = globalThis;
+var sharedStrategyRegistry = sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] ?? (sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] = {
+  registryStateByProjectRoot: /* @__PURE__ */ new Map()
+});
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  strategyEntriesMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
+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) {
+      logger.warn("Skip strategy entry without name from %s", source);
+      continue;
+    }
+    if (state.strategyCreators.has(strategyName)) {
+      logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyEntriesMap.set(strategyName, entry);
+    materializeStrategyCreator(strategyName, state);
+  }
+};
+var materializeStrategyCreator = (strategyName, state) => {
+  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
+    return;
+  }
+  const entry = state.strategyEntriesMap.get(strategyName);
+  if (!entry) return;
+  state.strategyCreators.set(
+    strategyName,
+    sharedStrategyRegistry.strategyRuntimeFactory({
+      strategyName,
+      defaults: entry.defaults,
+      createCore: entry.createCore,
+      manifest: entry.manifest,
+      detectorKey: entry.detectorKey,
+      detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+      resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
+    })
+  );
+};
+var setStrategyRuntimeFactory = (factory) => {
+  sharedStrategyRegistry.strategyRuntimeFactory = factory;
+  for (const state of registryStateByProjectRoot.values()) {
+    for (const strategyName of state.strategyEntriesMap.keys()) {
+      materializeStrategyCreator(strategyName, state);
+    }
+  }
+};
+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) {
+    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) {
+              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) {
+              logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerIndicatorEntries(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            logger.warn(
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
+              moduleName
+            );
+          }
+        } catch (error) {
+          logger.warn(
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
+};
+var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+};
+var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return Object.fromEntries(state.strategyCreators.entries());
+};
+var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyManifestsMap.values()];
+};
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
+};
+var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.has(name);
+};
+var registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
+};
+var resetStrategyRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    resetIndicatorRegistryCache();
+    return;
+  }
+  const projectRoot = getTradejsProjectCwd(normalizedCwd);
+  registryStateByProjectRoot.delete(projectRoot);
+  resetIndicatorRegistryCache(projectRoot);
+};
+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/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/ai.ts
+var toRecord2 = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+};
+var buildBaseAiPayload = (signal) => {
+  const additionalIndicators = {
+    ...toRecord2(signal.additionalIndicators),
+    marketContext: buildAiMarketContext(signal)
+  };
+  return {
+    signal: {
+      symbol: signal.symbol,
+      signalId: signal.signalId,
+      interval: signal.interval,
+      direction: signal.direction,
+      timestamp: signal.timestamp,
+      strategy: signal.strategy,
+      prices: {
+        currentPrice: signal.prices.currentPrice,
+        takeProfitPrice: signal.prices.takeProfitPrice,
+        stopLossPrice: signal.prices.stopLossPrice
+      }
+    },
+    figures: trimSeriesDeep(signal.figures ?? {}),
+    indicators: buildCompactAiIndicatorsSnapshot(signal.indicators),
+    additionalIndicators: trimSeriesDeep(additionalIndicators)
+  };
+};
+var defaultAiAdapter = {};
+var getStrategyAiAdapter = (strategy, profileId) => getStrategyProfileAiAdapter(getStrategyManifest(strategy), profileId) ?? defaultAiAdapter;
+var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy, signal.policyProfileId);
+var buildAiPayloadByStrategy = (signal) => {
+  const basePayload = buildBaseAiPayload(signal);
+  const adapter = getSignalAiAdapter(signal);
+  return adapter.buildPayload?.({ signal, basePayload }) ?? basePayload;
+};
+var buildAiSystemPromptAddonByStrategy = (signal) => getSignalAiAdapter(signal).buildSystemPromptAddon?.({ signal }) ?? "";
+var buildAiHumanPromptAddonByStrategy = (signal, payload) => getSignalAiAdapter(signal).buildHumanPromptAddon?.({
+  signal,
+  payload
+}) ?? "";
+var postProcessAiAnalysisByStrategy = (signal, analysis, payload = buildAiPayloadByStrategy(signal)) => getSignalAiAdapter(signal).postProcessAnalysis?.({
+  signal,
+  payload,
+  analysis
+}) ?? analysis;
+var postProcessLocalAiAnalysisByStrategy = (signal, analysis, payload = buildAiPayloadByStrategy(signal)) => {
+  const adapter = getSignalAiAdapter(signal);
+  const strategyAnalysis = adapter.postProcessAnalysis?.({ signal, payload, analysis }) ?? analysis;
+  return adapter.postProcessLocalAnalysis?.({
+    signal,
+    payload,
+    analysis: strategyAnalysis
+  }) ?? strategyAnalysis;
+};
+
+// src/ai.ts
+var parseAIResponse = (input) => {
+  try {
+    if (typeof input === "object" && input !== null) return input;
+    const match = input.match(/\{[\s\S]*\}/);
+    if (!match) throw new Error("JSON block not found");
+    return JSON.parse(match[0]);
+  } catch (err) {
+    console.error("Failed to parse AI response:", err);
+    console.log("Raw AI response:", input);
+    return {};
+  }
+};
+var normalizeResponseContent = (content) => {
+  if (typeof content === "string" || content && typeof content === "object") {
+    if (typeof content !== "object" || !Array.isArray(content)) {
+      return content;
+    }
+  }
+  if (Array.isArray(content)) {
+    const text = content.map((part) => typeof part?.text === "string" ? part.text : "").join("\n").trim();
+    return text;
+  }
+  return String(content ?? "");
+};
+var normalizeAnalysis = (raw) => {
+  const direction = raw?.direction === "LONG" || raw?.direction === "SHORT" ? raw.direction : null;
+  const qualityNum = typeof raw?.quality === "number" ? Math.max(1, Math.min(5, Math.round(raw.quality))) : void 0;
+  const toNumberOrNull = (value) => {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+    return null;
+  };
+  const toText = (value) => typeof value === "string" ? value.slice(0, 400) : void 0;
+  return {
+    direction,
+    quality: qualityNum,
+    needRetest: Boolean(raw?.needRetest),
+    retestPrice: toNumberOrNull(raw?.retestPrice),
+    takeProfitPrice: toNumberOrNull(raw?.takeProfitPrice),
+    stopLossPrice: toNumberOrNull(raw?.stopLossPrice),
+    setup: toText(raw?.setup),
+    confirmations: toText(raw?.confirmations),
+    btcContext: toText(raw?.btcContext),
+    retestPlan: toText(raw?.retestPlan),
+    riskLevels: toText(raw?.riskLevels),
+    qualityReason: toText(raw?.qualityReason),
+    triggerInvalidation: toText(raw?.triggerInvalidation),
+    comment: typeof raw?.comment === "string" ? raw.comment.slice(0, 1024) : ""
+  };
+};
+var asRecord = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+};
+var getSignalDirection = (signal) => signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : null;
+var getDeterministicQuality = (gateContext) => {
+  const deterministicQuality = Number(gateContext?.deterministicQuality);
+  if (Number.isFinite(deterministicQuality)) {
+    return Math.max(1, Math.min(5, Math.round(deterministicQuality)));
+  }
+  const maxAllowedQuality = Number(gateContext?.maxAllowedQuality);
+  if (Number.isFinite(maxAllowedQuality)) {
+    return Math.max(1, Math.min(5, Math.round(maxAllowedQuality)));
+  }
+  return Array.isArray(gateContext?.approvalBlockReasons) && gateContext.approvalBlockReasons.length > 0 || Array.isArray(gateContext?.structuralHardBlockReasons) && gateContext.structuralHardBlockReasons.length > 0 ? 2 : 3;
+};
+var buildAiSystemPrompt = (signal) => `
+You are an internal market-structure classifier for an already computed system signal.
+Analyze the provided JSON containing the trade, candles, indicators (for the coin and BTC across multiple timeframes), and strategy figures/context.
+Series data is already trimmed to the latest 5 values.
+
+Important:
+- Do not invent missing data.
+- This is an internal audit/classification task, not user-facing trading advice.
+- Do not generate execution instructions, do not replace the original thesis with a new one, and do not provide personalized investment advice.
+- Use the original signal direction and levels as the anchor, but you may state that the current structure does not support them.
+- Respect the source strategy specified in \`signal.strategy\`.
+- Your goal is to explain how well the observed structure matches the existing signal and how structurally confirmed it is right now.
+- Do not write vague statements like "there is momentum/slope" without tying them to the decision.
+- Write all user-visible text fields in the requested response language. If no explicit language instruction is provided later, default to English.
+- If confidence is incomplete, prefer cautious wording such as "likely", "not confirmed yet", or "probably" instead of categorical claims.
+
+Return exactly one JSON object and nothing else:
+
+{
+  "direction": payload.signal.direction | null,
+  "quality": 1 | 2 | 3 | 4 | 5,
+  "needRetest": boolean,
+  "retestPrice": number | null,
+  "takeProfitPrice": number | null,
+  "stopLossPrice": number | null,
+  "setup": string,
+  "confirmations": string,
+  "btcContext": string,
+  "retestPlan": string,
+  "riskLevels": string,
+  "qualityReason": string,
+  "triggerInvalidation": string
+}
+
+- Do not add any other fields.
+- All numbers must be finite, with no \`NaN\` or \`Infinity\`.
+- All text fields must be short strings with no line breaks and no markdown lists.
+- \`direction\` is not a new trade idea. It is only a compatibility flag for the existing signal: either exactly \`payload.signal.direction\` or \`null\` if the current structure does not confirm that signal. Never propose the opposite direction.
+- \`quality\` is the structural confirmation level of the current signal right now, including timing and confirmations. It is not a general attractiveness score and not investment advice.
+- \`needRetest\` indicates whether an additional confirmation level is required before the current signal can be treated as structurally confirmed.
+- \`retestPrice\` is the key level that would confirm or invalidate the structure, or \`null\` if no extra level is needed or available.
+- \`takeProfitPrice\` and \`stopLossPrice\` must not be newly invented levels. If the levels already supplied in \`payload.signal.prices\` still look internally coherent relative to the current price and the confirmed signal, you may return them as an audit of existing levels; otherwise return \`null\`.
+- Use these fields as separate parts of the analysis:
+  - \`setup\`: the current structural setup or trendline state.
+  - \`confirmations\`: 2-4 concrete confirmations or conflicts from the coin indicators.
+  - \`btcContext\`: whether BTC supports the idea, is neutral, or conflicts with it.
+  - \`retestPlan\`: what must happen at the key level to confirm the structure, or why no extra level is needed.
+  - \`riskLevels\`: a short note on whether the existing levels and risk structure are internally coherent, without creating a new trade plan.
+  - \`qualityReason\`: why the quality score is what it is.
+  - \`triggerInvalidation\`: what must happen to confirm the signal or what invalidates the current structural thesis.
+- \`comment\` is optional. If you include it, do not just duplicate the structured fields.
+
+If the data is insufficient or the setup is weak, return \`"direction": null\`, \`quality <= 2\`, and explain why.
+
+Input payload structure:
+- payload.signal:
+  symbol, signalId, interval, direction, timestamp, strategy, prices
+- payload.signal.prices:
+  currentPrice, takeProfitPrice, stopLossPrice
+- payload.figures:
+  strategy-specific figures or geometry when available. Fields vary by strategy.
+- payload.indicators:
+  historical indicator dictionaries and series for the coin and BTC; all series are already trimmed to the latest 5 values. Treat this block as recent-history transport, not as the primary source of the current shared context.
+- payload.additionalIndicators:
+  strategy-specific summary/context fields plus the canonical current shared context snapshot.
+  This is not noise; it contains derived fields deliberately passed by the strategy to help the decision.
+  Examples: baseContext, helperFlags, structureContext, volatilitySummary.
+  Always inspect \`payload.additionalIndicators.baseContext\` first for the current shared state:
+  \u2022 \`baseContext.raw\`: current MA, ATR, BB, OBV, price stats, levels, BTC correlation.
+  \u2022 \`baseContext.regime\`: derived trend / volatility / momentum / session regime fields.
+  \u2022 \`baseContext.structure\`: local range position, breakout freshness/quality, level-touch counts, rejection wick context.
+  \u2022 \`baseContext.participation\`: volume/turnover participation, effort-vs-result context, Binance aggTrades, and fingerprinted Hyperliquid whale-flow when available.
+  \u2022 \`baseContext.relative\`: BTC/ETH relative-strength, benchmark MA bias context, Binance alt-basket breadth, and CoinMarketCap historical global/exchange/index context when available.
+  \u2022 \`baseContext.derivatives\`: Coinalyze-aligned derivatives summary when available.
+  \u2022 \`baseContext.mtf\`: compact multi-timeframe summary plus only the latest few candles for each timeframe.
+  \u2022 \`baseContext.gateFeatures\`: compact direction-aware fields derived from baseContext; prefer \`setup\`, \`scores\`, \`conflicts\`, \`risk\`, \`decisionHints\`, \`mtf\`, \`volatility\`, \`participation\`, and \`relative\` for quick gate checks before inspecting raw nested context.
+  Always inspect \`payload.additionalIndicators.marketContext\` when present:
+  \u2022 \`marketContext.execution.binanceCoinbaseSpread\`: AI-friendly BTC spread view projected from \`payload.additionalIndicators.baseContext.relative.execution.venueSpread\`; \`value=(Coinbase-Binance)/Binance\`, \`bps=value*10000\`.
+  \u2022 \`marketContext.participation.trueDelta\`: Binance taker buy/sell volume delta from kline payload when \`source=kline_taker_volume\`; otherwise absent/unavailable.
+  \u2022 \`marketContext.participation.tradeFlow\`: Binance aggTrades buy/sell pressure buckets when available.
+  \u2022 \`marketContext.relative.marketBreadths.top5|top10|top30|top50|top100\`: equal/volume-weighted alt-basket return, advance/decline ratio, and MA breadth for the five versioned Binance breadth universes. \`marketBreadth\` remains the top30 primary view used by existing gates.
+  \u2022 \`marketContext.relative.targetVsBtc\`: target/BTC ratio returns, alpha, beta, and short-window correlation; use it to decide whether the target is leading or lagging BTC in the signal direction.
+  \u2022 \`marketContext.relative.btcAltRegime\`: Binance-derived BTC-vs-alt basket regime, BTC/alt 24h returns, BTC turnover share, and alt dispersion; use it as a broad alt-market risk pocket.
+  \u2022 \`marketContext.relative.cmcGlobal\`: historical CoinMarketCap global market metrics: total/alt market cap, total/alt volume, BTC/ETH dominance and 24h changes, active markets, \`interval\`, and \`altLiquidityRegime\`.
+  \u2022 \`marketContext.relative.cmcReferenceAssets\`: historical CoinMarketCap BTC/ETH market-cap and volume context, ETH/BTC market-cap ratio, ETH-vs-BTC volume ratio, \`interval\`, and \`referenceLiquidityRegime\`.
+  \u2022 \`marketContext.relative.cmcExchangeLiquidity\`: historical CoinMarketCap major-exchange liquidity aggregate: total volume, 24h volume change, Binance share, concentration, and \`liquidityRegime\`.
+  \u2022 \`marketContext.relative.cmcFearGreed\`: historical daily CoinMarketCap Fear & Greed sentiment index: value, classification, 24h/7d value changes, and \`sentimentRegime\`.
+  \u2022 \`marketContext.relative.cmcIndexes\`: historical daily CoinMarketCap CMC100/CMC20 index values, 24h changes, top constituents, CMC20/CMC100 ratio, and \`indexRegime\`.
+  \u2022 \`marketContext.relative.referenceTradeFlow\`: BTC/ETH reference trade-flow summary used for broad market pressure when the target symbol itself is not BTC/ETH.
+  If those fields exist, use them as a more explicit hint instead of trying to re-derive the same idea from raw lines or points.
+  If \`baseContext.derivatives\` exists, its top-level \`summary\` and \`intervals\` are the primary BTCUSDT Coinalyze benchmark context for the time of the signal. \`secondaryReferenceSymbol\` identifies the ETHUSDT secondary benchmark, and \`referenceContexts\` contains BTCUSDT/ETHUSDT plus configured extra reference symbols such as BNBUSDT/SOLUSDT/TRXUSDT/XRPUSDT. If \`targetContext\` or \`targetDerived\` exists, those fields are the Coinalyze context for the actual target coin; use them as target-specific positioning evidence, but do not infer target-coin derivatives when they are absent.
+  Key patterns:
+  \u2022 current shared state: prefer \`payload.additionalIndicators.baseContext\`
+  \u2022 recent historical series: \`payload.indicators\`
+  \u2022 strategy service keys are possible as well, for example \`touches\`, \`distance\`, timing flags, and other setup-specific summaries
+
+How to analyze, in order:
+1. Start with price structure and the setup geometry or context in \`payload.figures\`. This has higher priority than indicators.
+2. Then use \`payload.additionalIndicators.baseContext\` and other explicit strategy-specific context fields.
+3. Then assess confirmation or conflict from the current shared state and recent coin indicator history.
+4. Then evaluate BTC context.
+5. Only after that choose \`direction\`, \`quality\`, and whether an extra confirmation level is required.
+6. If strong conflicts exist, reduce quality or set direction to \`null\`.
+
+Explicit conflict rules:
+- If the figure or price structure is invalid or doubtful, indicators must not rescue the setup.
+- If strategy-specific helper fields explicitly say the signal is not confirmed yet, lacks margin, or requires waiting, do not overstate quality.
+- If the structure is acceptable but BTC or key indicators noticeably conflict, quality is usually \`<= 3\`.
+- If \`baseContext.derivatives.referenceContexts\` exists, check \`primaryReferenceSymbol\` first as the BTC benchmark, then compare \`secondaryReferenceSymbol\`/ETHUSDT and any target-specific \`targetDerived\`. If \`targetDerived\` exists, compare it to the primary reference instead of treating reference pressure as the target coin's own pressure.
+- If top-level \`baseContext.derivatives.summary.riskFlags\` contains \`crowded_long\` for a LONG or \`crowded_short\` for a SHORT, treat that as broad-market crowded positioning. If \`targetDerived.riskFlags\` contains the same directional crowding, treat that as target-specific crowded positioning.
+- If top-level \`baseContext.derivatives.summary.directionAligned=false\`, explicitly mention the broad-market derivatives conflict in \`confirmations\` or \`qualityReason\`. If \`targetDerived.directionAligned=false\`, explicitly mention the target-specific derivatives conflict.
+- If \`baseContext.derivatives\` is absent, stale, or \`missing_derivatives\`, do not infer Coinalyze conclusions and do not penalize the signal just because that data is missing.
+- Use \`baseContext.regime.session\` directly as the canonical session/liquidity regime: asia is often thinner, europe/us are more active, and overlaps can amplify both momentum and noise. Do not reject a signal solely because of session, but mention clear session support or conflict in \`confirmations\` or \`qualityReason\`.
+- If \`marketContext.execution.binanceCoinbaseSpread.available=true\` and \`severity=elevated/wide\`, treat it as cross-exchange divergence or BTC liquidity risk. Do not use the spread as a standalone long/short signal, but reduce confidence or require more confirmation when the rest of the structure is weak or BTC context conflicts.
+- If \`marketContext.execution.binanceCoinbaseSpread\` is missing or \`available=false\`, do not infer anything from Binance/Coinbase spread and do not penalize the signal just because it is absent.
+- If \`marketContext.participation.trueDelta.available=true\`, use it as better participation evidence than OHLCV-derived proxy delta; still do not let delta override invalid price structure.
+- If \`marketContext.participation.tradeFlow.available=true\` and \`stale=false\`, use it as direct lower-timeframe participation evidence. Treat stale or missing tradeFlow as absent, not as negative evidence.
+- If \`marketContext.relative.marketBreadth.available=true\` and \`stale=false\`, use it as broad alt-market support/conflict. Breadth is contextual; do not let it override the target symbol structure.
+- If \`marketContext.relative.targetVsBtc.available=true\`, treat positive target/BTC ratio trend as support for alt LONGs and negative ratio trend as support for alt SHORTs; ignore it when the target structure is stronger and clearly explains the setup.
+- If \`marketContext.relative.btcAltRegime.available=true\` and \`stale=false\`, treat \`alt_lead\`/\`risk_on\` as broad support for alt LONGs and \`btc_lead\`/\`risk_off\` as pressure against alt LONGs or support for cautious alt SHORTs. Do not use it as a standalone entry reason.
+- If \`marketContext.relative.cmcGlobal.available=true\` and \`stale=false\`, use falling alt market cap/volume or rising BTC dominance as broad risk pressure for alt LONGs. Treat missing CMC history as absent context, not a bearish signal.
+- If \`marketContext.relative.cmcReferenceAssets.available=true\` and \`stale=false\`, use \`eth_led\` as broad support for ETH/high-beta alt strength and \`btc_led\`/\`thin\` as broad caution. Do not describe BTC/ETH reference history as target-symbol flow.
+- If \`marketContext.relative.cmcExchangeLiquidity.available=true\` and \`stale=false\`, treat \`contracting\`, \`thin\`, or \`concentrated\` as broad liquidity risk; \`expanding\` or \`balanced\` supports cleaner execution context but is not a standalone entry reason.
+- If \`marketContext.relative.cmcFearGreed.available=true\` and \`stale=false\`, use \`risk_on\` as broad support for LONGs and \`risk_off\`/\`capitulation\` as broad pressure. Treat \`euphoric\` as overheating/chase caution, not as standalone SHORT proof.
+- If \`marketContext.relative.cmcIndexes.available=true\` and \`stale=false\`, use \`top20_led\` as broad support for mega-cap leadership, \`large_cap_led\` as broader CMC100 participation, and \`risk_off\` as broad pressure. Do not use CMC index history as a standalone entry reason.
+- If \`marketContext.relative.referenceTradeFlow.available=true\`, treat BTC/ETH trade-flow as broad market context only. For alt symbols, do not describe it as the target coin's own flow.
+- If the current signal is not confirmed (\`direction=null\`), name the main reason briefly in \`comment\`.
+  If you use the structured fields, include the main reason in \`qualityReason\` or \`triggerInvalidation\`.
+
+Rules for \`direction\` / TP / SL:
+- \`direction = LONG\` only if the data confirms the existing LONG signal; \`SHORT\` only if the data confirms the existing SHORT signal; otherwise \`null\`.
+- For LONG, the expected relation is usually \`stopLossPrice < currentPrice < takeProfitPrice\`.
+- For SHORT, the expected relation is usually \`takeProfitPrice < currentPrice < stopLossPrice\`.
+- Do not optimize or recalculate TP/SL for a "better trade"; only assess whether the already supplied levels are coherent.
+- If \`direction = null\`, then \`takeProfitPrice = null\` and \`stopLossPrice = null\`.
+- If \`needRetest = false\`, then \`retestPrice = null\`.
+- If \`needRetest = true\`, \`retestPrice\` must be a finite number tied to a meaningful retest or breakout level.
+- Before responding, sanity-check the consistency of \`direction\`, TP/SL, and the current price.
+
+Quality scale:
+- 1: poor or chaotic setup, strong conflicts, signal not structurally confirmed
+- 2: weak setup, few confirmations, more of a watch or reject
+- 3: average setup, some structure exists, but notable conflicts remain
+- 4: good setup, several confirmations, structure is mostly coherent
+- 5: very strong setup, clean structure, confirmations, and internally coherent levels
+
+Requirements for useful structured analysis:
+- Include 2-4 concrete factors for or against confirmation in \`confirmations\`.
+- Explicitly mention the role of the key figure or structural state, for example breakout, retest, false break, touch, or lack of confirmation.
+- Explicitly mention BTC context as supportive, neutral, or conflicting.
+- Explain why the quality score is what it is.
+- If the signal is not confirmed (\`direction=null\`), state clearly what must change for confirmation.
+- In \`retestPlan\`, avoid technical placeholders like \`needRetest=false @ null\`; write a human explanation.
+- Do not simply restate JSON fields; add interpretation and decision logic.
+
+Rules for using trimmed series (last 5 values):
+- Do not make strong long-term conclusions from only 5 points.
+- Use 4h and 1d series as brief context, not full history.
+- If the data is too limited for confidence, reduce quality and use cautious wording.
+
+Short few-shot examples:
+{"direction":"LONG","quality":4,"needRetest":true,"retestPrice":100.2,"takeProfitPrice":101.5,"stopLossPrice":98.9,"setup":"Likely trendline breakout upward, but the signal still needs a level check for confirmation.","confirmations":"The coin shows momentum support without obvious overheating, but confirmation is not fully clean yet.","btcContext":"BTC is neutral-to-supportive and does not conflict with the current LONG signal.","retestPlan":"The key level is 100.2; holding above it would confirm the signal structure.","riskLevels":"The supplied TP and SL remain on the correct sides of the current price and still look internally coherent.","qualityReason":"Quality=4 because the structure is solid, but an extra level confirmation is still preferable.","triggerInvalidation":"The structure confirms on a hold above the level and weakens on a move back under the line."}
+{"direction":null,"quality":2,"needRetest":false,"retestPrice":null,"takeProfitPrice":null,"stopLossPrice":null,"setup":"Touch or noise around the trendline without a convincing breakout.","confirmations":"Indicators are mixed and do not provide strong structural support.","btcContext":"BTC is either conflicting or not supportive of the current thesis.","retestPlan":"It is too early to define an extra level because a quality breakout is not present yet.","riskLevels":"The supplied levels should not be treated as confirmed while the structure remains weak.","qualityReason":"Quality=2 because timing is weak and confirmations are limited.","triggerInvalidation":"Wait for a clear breakout and confirmation from both the coin and BTC."}
+
+Return only the JSON object, with no extra characters.
+${signal ? buildAiSystemPromptAddonByStrategy(signal) : ""}
+`;
+var buildAiPayload = (signal) => buildAiPayloadByStrategy(signal);
+var getDeterministicAiGateContext = (payload) => {
+  const additionalIndicators = asRecord(payload.additionalIndicators);
+  const candidates = [
+    additionalIndicators,
+    ...Object.values(additionalIndicators ?? {}).map(asRecord)
+  ].filter((value) => Boolean(value));
+  return candidates.find(
+    (candidate) => Array.isArray(candidate.approvalBlockReasons) || Array.isArray(candidate.riskAnnotations) || Array.isArray(candidate.structuralHardBlockReasons) || typeof candidate.approvalAllowedNow === "boolean"
+  ) ?? null;
+};
+var buildAiHumanPrompt = (signal, payload = buildAiPayload(signal)) => `
+Analyze the already computed internal signal for ${signal.symbol}. The original signal direction is ${signal.direction}.
+This is a structure-classification and audit task, not execution advice. Determine whether the current structure confirms the existing signal, how structurally coherent it is right now, whether an extra confirmation level is needed, and whether the already supplied levels in \`payload.signal.prices\` still look internally coherent. Do not replace the original thesis with a new one and do not invent new levels; return only the requested JSON.
+
+Trade payload:
+${JSON.stringify(payload)}
+${buildAiHumanPromptAddonByStrategy(signal, payload)}
+`;
+var getAiInvocationError = (error) => {
+  const details = error instanceof Error && error.message.trim() ? error.message.trim() : String(error);
+  const isEmptyCompletion = error instanceof TypeError && /Cannot read properties of undefined \(reading ['"]message['"]\)/.test(
+    details
+  );
+  const wrapped = new Error(
+    isEmptyCompletion ? "AI provider returned an empty chat completion" : `AI model invocation failed: ${details}`
+  );
+  wrapped.cause = error;
+  return wrapped;
+};
+var isEmptyResponseContent = (content) => typeof content === "string" ? content.trim().length === 0 : Object.keys(content).length === 0;
+var DEFAULT_AI_MODEL = "openai/gpt-5-mini";
+var userSettingsCache = /* @__PURE__ */ new Map();
+var aiModelCache = /* @__PURE__ */ new Map();
+var getAiModelCacheKey = (userName, modelName) => `${userName}::${modelName}`;
+var resolveAiModelName = (settings, requestedModelName) => {
+  const explicitModelName = typeof requestedModelName === "string" ? requestedModelName.trim() : "";
+  if (explicitModelName) {
+    return explicitModelName;
+  }
+  const settingsModelName = typeof settings.AI_MODEL === "string" ? settings.AI_MODEL.trim() : "";
+  return settingsModelName || DEFAULT_AI_MODEL;
+};
+var getOpenRouterModelKwargs = (apiEndpoint) => {
+  const endpoint = String(apiEndpoint ?? "").trim();
+  if (!endpoint) {
+    return {};
+  }
+  let hostname = "";
+  try {
+    hostname = new URL(endpoint).hostname;
+  } catch {
+    hostname = endpoint;
+  }
+  if (!hostname.toLowerCase().includes("openrouter")) {
+    return {};
+  }
+  return {
+    provider: {
+      ignore: ["azure"]
+    }
+  };
+};
+var getAiSettings = async (userName = "root") => {
+  let settingsPromise = userSettingsCache.get(userName);
+  if (!settingsPromise) {
+    settingsPromise = getUserSettings(userName).then((settings2) => {
+      const endpoint = normalizeAiEndpoint(settings2.AI_API_ENDPOINT);
+      return {
+        ...settings2,
+        AI_API_ENDPOINT: endpoint,
+        AI_MODEL: normalizeAiModel(settings2.AI_MODEL, endpoint),
+        AI_RESPONSE_LANGUAGE: normalizeAiResponseLanguage(
+          settings2.AI_RESPONSE_LANGUAGE
+        )
+      };
+    });
+    settingsPromise.catch(() => {
+      userSettingsCache.delete(userName);
+    });
+    userSettingsCache.set(userName, settingsPromise);
+  }
+  const settings = await settingsPromise;
+  if (!settings.AI_API_KEY || !settings.AI_API_ENDPOINT) {
+    throw new Error(`AI settings are incomplete for user ${userName}`);
+  }
+  return settings;
+};
+var createAiModel = async (userName = "root", requestedModelName) => {
+  const settings = await getAiSettings(userName);
+  const modelName = resolveAiModelName(settings, requestedModelName);
+  const cacheKey = getAiModelCacheKey(userName, modelName);
+  let modelPromise = aiModelCache.get(cacheKey);
+  if (!modelPromise) {
+    modelPromise = (async () => {
+      const { ChatOpenAI } = await import("@langchain/openai");
+      const modelKwargs = getOpenRouterModelKwargs(settings.AI_API_ENDPOINT);
+      return new ChatOpenAI({
+        temperature: 0.2,
+        modelName,
+        apiKey: settings.AI_API_KEY,
+        ...Object.keys(modelKwargs).length ? { modelKwargs } : {},
+        configuration: {
+          baseURL: settings.AI_API_ENDPOINT,
+          defaultHeaders: {
+            "HTTP-Referer": "https://tradejs.dev",
+            "X-Title": "Inv"
+          }
+        }
+      });
+    })();
+    modelPromise.catch(() => {
+      aiModelCache.delete(cacheKey);
+    });
+    aiModelCache.set(cacheKey, modelPromise);
+  }
+  return modelPromise;
+};
+var getAiModel = async (userName = "root", requestedModelName) => {
+  const settings = await getAiSettings(userName);
+  const resolvedModelName = resolveAiModelName(settings, requestedModelName);
+  try {
+    return await createAiModel(userName, resolvedModelName);
+  } catch (error) {
+    aiModelCache.delete(getAiModelCacheKey(userName, resolvedModelName));
+    userSettingsCache.delete(userName);
+    throw error;
+  }
+};
+var resetAiRuntimeCache = () => {
+  aiModelCache.clear();
+  userSettingsCache.clear();
+};
+var buildAiPrompts = (signal) => {
+  const payload = buildAiPayload(signal);
+  return {
+    systemPrompt: buildAiSystemPrompt(signal),
+    humanPrompt: buildAiHumanPrompt(signal, payload)
+  };
+};
+var runAiPrompt = async ({ systemPrompt, humanPrompt }, options = {}) => {
+  const [{ HumanMessage, SystemMessage }, model, settings] = await Promise.all([
+    import("@langchain/core/messages"),
+    getAiModel(options.userName, options.model),
+    getAiSettings(options.userName)
+  ]);
+  const messages = [];
+  const responseLanguage = getAiResponseLanguagePromptName(
+    settings.AI_RESPONSE_LANGUAGE || DEFAULT_AI_RESPONSE_LANGUAGE
+  );
+  messages.push(new SystemMessage(systemPrompt));
+  messages.push(
+    new SystemMessage(
+      `Write all user-visible text fields in ${responseLanguage}. Keep field names and JSON syntax unchanged.`
+    )
+  );
+  messages.push(
+    new HumanMessage({
+      content: [
+        {
+          type: "text",
+          text: humanPrompt
+        }
+      ]
+    })
+  );
+  let response;
+  try {
+    response = await model.invoke(messages);
+  } catch (error) {
+    throw getAiInvocationError(error);
+  }
+  const responseContent = normalizeResponseContent(response?.content);
+  if (isEmptyResponseContent(responseContent)) {
+    throw new Error("AI provider returned an empty chat completion");
+  }
+  const parsed = parseAIResponse(responseContent);
+  const normalized = normalizeAnalysis(parsed);
+  if (!options.signal) {
+    return normalized;
+  }
+  return postProcessAiAnalysisByStrategy(
+    options.signal,
+    normalized,
+    options.payload
+  );
+};
+var runAiPromptLocal = async (signal, options = {}) => {
+  const payload = options.payload ?? buildAiPayload(signal);
+  const gateContext = getDeterministicAiGateContext(payload);
+  const signalDirection = getSignalDirection(signal);
+  const deterministicQuality = getDeterministicQuality(gateContext);
+  const approvalAllowedNow = typeof gateContext?.approvalAllowedNow === "boolean" ? gateContext.approvalAllowedNow : deterministicQuality >= 4;
+  return postProcessLocalAiAnalysisByStrategy(
+    signal,
+    {
+      direction: approvalAllowedNow ? signalDirection : null,
+      quality: deterministicQuality,
+      needRetest: !approvalAllowedNow,
+      retestPrice: null,
+      takeProfitPrice: approvalAllowedNow ? signal.prices?.takeProfitPrice ?? null : null,
+      stopLossPrice: approvalAllowedNow ? signal.prices?.stopLossPrice ?? null : null
+    },
+    payload
+  );
+};
+var askAI = async (signal, options = {}) => {
+  const { symbol } = signal;
+  const payload = buildAiPayload(signal);
+  const content = await runAiPrompt(
+    {
+      systemPrompt: buildAiSystemPrompt(signal),
+      humanPrompt: buildAiHumanPrompt(signal, payload)
+    },
+    {
+      ...options,
+      signal,
+      payload
+    }
+  );
+  await setData(redisKeys.analysis(symbol, signal.signalId), content);
+  return content;
+};
+
+export {
+  MAX_AI_SERIES_POINTS,
+  trimSeriesDeep,
+  buildCompactAiIndicatorsSnapshot,
+  setStrategyRuntimeFactory,
+  ensureStrategyPluginsLoaded,
+  ensureIndicatorPluginsLoaded,
+  getStrategyCreator,
+  getAvailableStrategyNames,
+  getRegisteredStrategies,
+  getRegisteredManifests,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies,
+  resolveStrategyPolicyProfile,
+  getStrategyProfileMlAdapter,
+  buildAiSystemPrompt,
+  buildAiPayload,
+  getDeterministicAiGateContext,
+  buildAiHumanPrompt,
+  DEFAULT_AI_MODEL,
+  getOpenRouterModelKwargs,
+  resetAiRuntimeCache,
+  buildAiPrompts,
+  runAiPrompt,
+  runAiPromptLocal,
+  askAI
+};