@tradejs/node 1.0.9 → 1.0.10

package/dist/ai.js

@@ -37,6 +37,7 @@ __export(ai_exports, {
   buildAiPayload: () => buildAiPayload,
   buildAiPrompts: () => buildAiPrompts,
   buildAiSystemPrompt: () => buildAiSystemPrompt,
+  buildCompactAiIndicatorsSnapshot: () => buildCompactAiIndicatorsSnapshot,
   ensureAiStrategyPluginsLoaded: () => ensureAiStrategyPluginsLoaded,
   getDeterministicAiGateContext: () => getDeterministicAiGateContext,
   getOpenRouterModelKwargs: () => getOpenRouterModelKwargs,
@@ -52,6 +53,10 @@ var import_userSettings = require("@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);
@@ -73,13 +78,15 @@ var trimSeriesDeep = (value) => {
   }
   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 SESSION_WINDOWS = [
-  { name: "asia", startMinuteUtc: 0, endMinuteUtc: 8 * 60 },
-  { name: "europe", startMinuteUtc: 7 * 60, endMinuteUtc: 16 * 60 },
-  { name: "us", startMinuteUtc: 13 * 60, endMinuteUtc: 22 * 60 }
-];
 var toRecord = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -90,92 +97,485 @@ 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 getLastFiniteNumber = (value) => {
-  const numeric = toFiniteNumber(value);
-  if (numeric != null) {
-    return numeric;
-  }
-  if (!Array.isArray(value)) {
-    return null;
-  }
-  for (let i = value.length - 1; i >= 0; i -= 1) {
-    const nested = getLastFiniteNumber(value[i]);
-    if (nested != null) {
-      return nested;
-    }
-  }
-  return null;
-};
 var roundTo = (value, decimals) => {
   const factor = 10 ** decimals;
   return Math.round(value * factor) / factor;
 };
-var isInsideSession = (minuteUtc, startMinuteUtc, endMinuteUtc) => startMinuteUtc <= endMinuteUtc ? minuteUtc >= startMinuteUtc && minuteUtc < endMinuteUtc : minuteUtc >= startMinuteUtc || minuteUtc < endMinuteUtc;
-var buildTradingSessionContext = (timestamp) => {
-  const date = new Date(timestamp);
-  const utcHour = date.getUTCHours();
-  const utcMinute = date.getUTCMinutes();
-  const minuteUtc = utcHour * 60 + utcMinute;
-  const activeSessions = SESSION_WINDOWS.filter(
-    (session) => isInsideSession(minuteUtc, session.startMinuteUtc, session.endMinuteUtc)
-  ).map((session) => session.name);
-  const primarySession = activeSessions.includes("us") ? "us" : activeSessions.includes("europe") ? "europe" : activeSessions.includes("asia") ? "asia" : "off_hours";
-  return {
-    timezone: "UTC",
-    utcHour,
-    utcMinute,
-    primarySession,
-    activeSessions,
-    isOverlap: activeSessions.length > 1,
-    overlap: activeSessions.length > 1 ? `${activeSessions.join("_")}_overlap` : null
-  };
-};
 var buildMissingSpreadContext = () => ({
-  source: "binance_coinbase_btc",
-  indicatorKey: "payload.indicators.spread",
+  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 buildSpreadContextFromValue = (spread) => {
+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 = Math.abs(bps) < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
+  const bias = absBps < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
   const severity = absBps >= 20 ? "wide" : absBps >= 5 ? "elevated" : "normal";
   return {
-    source: "binance_coinbase_btc",
-    indicatorKey: "payload.indicators.spread",
+    source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
     available: true,
     value,
+    zScore,
     bps,
     absBps,
     bias,
     severity
   };
 };
-var readSpreadFromSignal = (signal) => {
-  const indicatorSpread = getLastFiniteNumber(signal.indicators?.spread);
-  if (indicatorSpread != null) {
-    return indicatorSpread;
+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 getLastFiniteNumber(signal.additionalIndicators?.spread);
+  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 buildAiMarketContext = (signal) => {
-  const existingMarketContext = toRecord(
-    signal.additionalIndicators?.marketContext
-  );
-  const existingSpread = toRecord(existingMarketContext?.binanceCoinbaseSpread);
-  const spread = readSpreadFromSignal(signal);
+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 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 {
-    ...existingMarketContext ?? {},
-    tradingSession: buildTradingSessionContext(signal.timestamp),
-    binanceCoinbaseSpread: spread != null ? buildSpreadContextFromValue(spread) : existingSpread ?? buildMissingSpreadContext()
+    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),
+    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
 var import_indicators = require("@tradejs/core/indicators");
@@ -184,7 +584,6 @@ var import_logger2 = require("@tradejs/infra/logger");
 // src/tradejsConfig.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var import_module = require("module");
 var import_url = require("url");
 var import_config = require("@tradejs/core/config");
 var import_logger = require("@tradejs/infra/logger");
@@ -200,6 +599,7 @@ var cachedByCwd = /* @__PURE__ */ new Map();
 var announcedConfigFile = /* @__PURE__ */ new Set();
 var tsNodeRegistered = false;
 var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
+var tsconfigPathMatchersByCwd = /* @__PURE__ */ new Map();
 var getTradejsProjectCwd = (cwd) => {
   const explicit = String(cwd ?? "").trim();
   if (explicit) {
@@ -229,7 +629,14 @@ var normalizeConfig = (rawConfig) => {
     ...hooks ? { hooks } : {}
   };
 };
-var getRequireFn = (cwd = getTradejsProjectCwd()) => (0, import_module.createRequire)(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
+var getNodeCreateRequire = () => {
+  const builtinModule = process.getBuiltinModule?.("module");
+  if (typeof builtinModule?.createRequire === "function") {
+    return builtinModule.createRequire;
+  }
+  throw new TypeError("module.createRequire is not available");
+};
+var getRequireFn = (cwd = getTradejsProjectCwd()) => getNodeCreateRequire()(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
 var ensureTsNodeRegistered = async () => {
   if (tsNodeRegistered) {
     return;
@@ -239,8 +646,8 @@ var ensureTsNodeRegistered = async () => {
   tsNode.register?.({
     transpileOnly: true,
     compilerOptions: {
-      module: "commonjs",
-      moduleResolution: "node"
+      module: "Node16",
+      moduleResolution: "node16"
     }
   });
   tsNodeRegistered = true;
@@ -267,6 +674,42 @@ var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
   });
   tsconfigPathsRegisteredByCwd.add(projectRoot);
 };
+var resolveTsconfigPathModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  const cachedMatcher = tsconfigPathMatchersByCwd.get(projectRoot);
+  if (cachedMatcher) {
+    const resolved2 = cachedMatcher(moduleName);
+    return resolved2 || null;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const createMatchPath = tsconfigPathsModule.createMatchPath;
+  if (typeof loadConfig !== "function" || typeof createMatchPath !== "function") {
+    return null;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return null;
+  }
+  const matchPath = createMatchPath(
+    loadedConfig.absoluteBaseUrl,
+    loadedConfig.paths
+  );
+  const matcher = (requestedModule) => matchPath(requestedModule, void 0, import_fs.default.existsSync, [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json"
+  ]) || "";
+  tsconfigPathMatchersByCwd.set(projectRoot, matcher);
+  const resolved = matcher(moduleName);
+  return resolved || null;
+};
 var toImportSpecifier = (moduleName) => {
   if (moduleName.startsWith("file://")) {
     return moduleName;
@@ -325,7 +768,18 @@ var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   }
   if (isBareModuleSpecifier(normalized)) {
     await ensureTsconfigPathsRegistered(cwd);
-    return requireFn(normalized);
+    try {
+      return requireFn(normalized);
+    } catch (error) {
+      const resolvedByTsconfig = await resolveTsconfigPathModule(
+        normalized,
+        cwd
+      );
+      if (resolvedByTsconfig && resolvedByTsconfig !== normalized) {
+        return requireFn(resolvedByTsconfig);
+      }
+      throw error;
+    }
   }
   try {
     return await import(
@@ -595,6 +1049,9 @@ var strategies = new Proxy(
   }
 );
 
+// src/strategy/policyProfiles.ts
+var getStrategyProfileAiAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.aiAdapter ?? manifest?.aiAdapter;
+
 // src/strategyAdapters/ai.ts
 var toRecord2 = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -622,13 +1079,13 @@ var buildBaseAiPayload = (signal) => {
       }
     },
     figures: trimSeriesDeep(signal.figures ?? {}),
-    indicators: trimSeriesDeep(signal.indicators),
+    indicators: buildCompactAiIndicatorsSnapshot(signal.indicators),
     additionalIndicators: trimSeriesDeep(additionalIndicators)
   };
 };
 var defaultAiAdapter = {};
-var getStrategyAiAdapter = (strategy) => getStrategyManifest(strategy)?.aiAdapter ?? defaultAiAdapter;
-var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy);
+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);
@@ -715,7 +1172,7 @@ var getDeterministicQuality = (gateContext) => {
   if (Number.isFinite(maxAllowedQuality)) {
     return Math.max(1, Math.min(5, Math.round(maxAllowedQuality)));
   }
-  return Array.isArray(gateContext?.structuralHardBlockReasons) && gateContext.structuralHardBlockReasons.length > 0 ? 2 : 3;
+  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.
@@ -779,24 +1236,44 @@ Input payload structure:
 - payload.figures:
   strategy-specific figures or geometry when available. Fields vary by strategy.
 - payload.indicators:
-  indicator dictionaries and series for the coin and BTC; all series are already trimmed to the latest 5 values.
+  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. This is not noise; it contains derived fields deliberately passed by the strategy to help the decision.
-  Examples: helperFlags, structureContext, spread, correlation, volatilitySummary.
+  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, and Binance aggTrades trade-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\`: direction-aware, normalized fields derived from baseContext; prefer \`setup\`, \`scores\`, \`confirmations\`, \`conflicts\`, \`risk\`, and \`decisionHints\` for quick gate checks before inspecting raw nested context.
   Always inspect \`payload.additionalIndicators.marketContext\` when present:
-  \u2022 \`marketContext.tradingSession\`: UTC session at signal time: asia / europe / us / overlap / off_hours.
-  \u2022 \`marketContext.binanceCoinbaseSpread\`: BTC spread between Coinbase and Binance from \`payload.indicators.spread\`; \`value=(Coinbase-Binance)/Binance\`, \`bps=value*10000\`.
+  \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.marketBreadth\`: equal/volume-weighted alt-basket return, advance/decline ratio, and MA breadth for the configured Binance breadth universe.
+  \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 \`derivativesContext\` exists, it is a derived Coinalyze summary for the time of the signal. Coinalyze context is built only from \`BTCUSDT\` and \`ETHUSDT\` reference symbols, not for every target coin. \`targetSymbol\` is just the source signal coin. Use BTC/ETH open interest, funding, liquidations, and pressure/riskFlags as positioning context, not as an independent trade idea.
+  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 coin: \`maFast\`, \`atrPct\`, \`macd...\`, \`candles15m/candles1h/candles4h/candles1d\`, and \`*1h/*4h/*1d\`
-  \u2022 BTC: \`btcMaFast\`, \`btcAtr\`, \`btcMacd...\`, \`btcCandles*\`, and \`btc*1h/*4h/*1d\`
-  \u2022 strategy service keys are possible as well, for example \`correlation\`, \`spread\`, \`touches\`, \`distance\`
+  \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\` when it contains explicit strategy-specific context such as line state, spread, correlation, and similar fields.
-3. Then assess confirmation or conflict from the current coin 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\`.
@@ -805,13 +1282,24 @@ 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 \`derivativesContext.referenceContexts\` exists, check \`primaryReferenceSymbol\` first, then compare \`BTCUSDT\` and \`ETHUSDT\` as broad-market derivatives context. Do not search for Coinalyze data for \`targetSymbol\` unless \`targetSymbol\` itself is \`BTCUSDT\` or \`ETHUSDT\`.
-- If \`derivativesContext.summary.riskFlags\` contains \`crowded_long\` for a LONG or \`crowded_short\` for a SHORT, treat that as crowded positioning and do not overstate quality without strong structural confirmation.
-- If \`derivativesContext.summary.directionAligned=false\`, explicitly mention the derivatives conflict in \`confirmations\` or \`qualityReason\`.
-- If \`derivativesContext\` is absent, stale, or \`missing_derivatives\`, do not infer Coinalyze conclusions and do not penalize the signal just because that data is missing.
-- If \`marketContext.tradingSession\` exists, treat the session as a liquidity and volatility 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.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.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 \`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\`.
 
@@ -861,7 +1349,7 @@ var getDeterministicAiGateContext = (payload) => {
     ...Object.values(additionalIndicators ?? {}).map(asRecord)
   ].filter((value) => Boolean(value));
   return candidates.find(
-    (candidate) => Array.isArray(candidate.structuralHardBlockReasons) || typeof candidate.approvalAllowedNow === "boolean"
+    (candidate) => Array.isArray(candidate.approvalBlockReasons) || Array.isArray(candidate.riskAnnotations) || Array.isArray(candidate.structuralHardBlockReasons) || typeof candidate.approvalAllowedNow === "boolean"
   ) ?? null;
 };
 var buildAiHumanPrompt = (signal, payload = buildAiPayload(signal)) => `
@@ -872,6 +1360,18 @@ 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();
@@ -1003,10 +1503,17 @@ var runAiPrompt = async ({ systemPrompt, humanPrompt }, options = {}) => {
       ]
     })
   );
-  const response = await model.invoke(messages);
-  const parsed = parseAIResponse(
-    normalizeResponseContent(response.content)
-  );
+  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;
@@ -1064,6 +1571,7 @@ var askAI = async (signal, options = {}) => {
   buildAiPayload,
   buildAiPrompts,
   buildAiSystemPrompt,
+  buildCompactAiIndicatorsSnapshot,
   ensureAiStrategyPluginsLoaded,
   getDeterministicAiGateContext,
   getOpenRouterModelKwargs,